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

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

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

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

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

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

/// Internal type 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 246.
#[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 249.
#[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 252.
#[derive(Clone, Debug)]
pub enum DivConstMagicS32 {
    S32 {
        mul_by: i32,
        shift_by: u32,
    },
}

/// Internal type DivConstMagicS64: defined at src/prelude_opt.isle line 254.
#[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 355.
    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 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 v102,
                                    args: ref v103,
                                } => {
                                    match v102 {
                                        &Opcode::Smin => {
                                            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 v138,
                                                            args: ref v139,
                                                        } => {
                                                            match v138 {
                                                                &Opcode::Smax => {
                                                                    if v2.0 == v11.0 {
                                                                        let v104 = C::unpack_value_array_2(ctx, v103);
                                                                        let v140 = C::unpack_value_array_2(ctx, v139);
                                                                        if v104.0 == v140.0 {
                                                                            if v104.1 == v140.1 {
                                                                                let v284 = constructor_smin(ctx, v2.0, v104.0, v104.1);
                                                                                // Rule at src/opts/arithmetic.isle line 420.
                                                                                returns.extend(Some(v284));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                        if v104.0 == v140.1 {
                                                                            if v104.1 == v140.0 {
                                                                                let v284 = constructor_smin(ctx, v2.0, v104.0, v104.1);
                                                                                // Rule at src/opts/arithmetic.isle line 421.
                                                                                returns.extend(Some(v284));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Umax => {
                                                                    if v2.0 == v11.0 {
                                                                        let v104 = C::unpack_value_array_2(ctx, v103);
                                                                        let v140 = C::unpack_value_array_2(ctx, v139);
                                                                        if v104.0 == v140.0 {
                                                                            if v104.1 == v140.1 {
                                                                                let v284 = constructor_smin(ctx, v2.0, v104.0, v104.1);
                                                                                // Rule at src/opts/arithmetic.isle line 422.
                                                                                returns.extend(Some(v284));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                        if v104.0 == v140.1 {
                                                                            if v104.1 == v140.0 {
                                                                                let v284 = constructor_smin(ctx, v2.0, v104.0, v104.1);
                                                                                // Rule at src/opts/arithmetic.isle line 423.
                                                                                returns.extend(Some(v284));
                                                                                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 v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let mut v114 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                                    let mut v114 = v114.into_context_iter();
                                                                    while let Some(v115) = v114.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v132,
                                                                            imm: v133,
                                                                        } = &v115.1 {
                                                                            if let &Opcode::Iconst = v132 {
                                                                                if v2.0 == v115.0 {
                                                                                    let v1041 = constructor_smin(ctx, v2.0, v104.1, v7.1);
                                                                                    let v1042 = constructor_smin(ctx, v2.0, v104.0, v1041);
                                                                                    // Rule at src/opts/cprop.isle line 237.
                                                                                    returns.extend(Some(v1042));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let v104 = C::unpack_value_array_2(ctx, v103);
                                                if v7.1 == v104.0 {
                                                    let v284 = constructor_smin(ctx, v2.0, v104.0, v104.1);
                                                    // Rule at src/opts/arithmetic.isle line 387.
                                                    returns.extend(Some(v284));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.1 == v104.1 {
                                                    let v285 = constructor_smin(ctx, v2.0, v104.1, v104.0);
                                                    // Rule at src/opts/arithmetic.isle line 388.
                                                    returns.extend(Some(v285));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        &Opcode::Umin => {
                                            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 v138,
                                                        args: ref v139,
                                                    } = &v11.1 {
                                                        match v138 {
                                                            &Opcode::Smax => {
                                                                if v2.0 == v11.0 {
                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let v140 = C::unpack_value_array_2(ctx, v139);
                                                                    if v104.0 == v140.0 {
                                                                        if v104.1 == v140.1 {
                                                                            let v288 = constructor_umin(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 430.
                                                                            returns.extend(Some(v288));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        if v104.1 == v140.0 {
                                                                            let v288 = constructor_umin(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 431.
                                                                            returns.extend(Some(v288));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Umax => {
                                                                if v2.0 == v11.0 {
                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let v140 = C::unpack_value_array_2(ctx, v139);
                                                                    if v104.0 == v140.0 {
                                                                        if v104.1 == v140.1 {
                                                                            let v284 = constructor_smin(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 432.
                                                                            returns.extend(Some(v284));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        if v104.1 == v140.0 {
                                                                            let v284 = constructor_smin(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 433.
                                                                            returns.extend(Some(v284));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Smax => {
                                            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 v138,
                                                        args: ref v139,
                                                    } = &v11.1 {
                                                        match v138 {
                                                            &Opcode::Smin => {
                                                                if v2.0 == v11.0 {
                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let v140 = C::unpack_value_array_2(ctx, v139);
                                                                    if v104.0 == v140.0 {
                                                                        if v104.1 == v140.1 {
                                                                            let v284 = constructor_smin(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 415.
                                                                            returns.extend(Some(v284));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        if v104.1 == v140.0 {
                                                                            let v284 = constructor_smin(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 416.
                                                                            returns.extend(Some(v284));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Umin => {
                                                                if v2.0 == v11.0 {
                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let v140 = C::unpack_value_array_2(ctx, v139);
                                                                    if v104.0 == v140.0 {
                                                                        if v104.1 == v140.1 {
                                                                            let v288 = constructor_umin(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 417.
                                                                            returns.extend(Some(v288));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        if v104.1 == v140.0 {
                                                                            let v288 = constructor_umin(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 418.
                                                                            returns.extend(Some(v288));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                    }
                                                }
                                                let v104 = C::unpack_value_array_2(ctx, v103);
                                                if v7.1 == v104.0 {
                                                    // Rule at src/opts/arithmetic.isle line 398.
                                                    returns.extend(Some(v104.0));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.1 == v104.1 {
                                                    // Rule at src/opts/arithmetic.isle line 397.
                                                    returns.extend(Some(v104.1));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        &Opcode::Umax => {
                                            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 v138,
                                                        args: ref v139,
                                                    } = &v11.1 {
                                                        match v138 {
                                                            &Opcode::Smin => {
                                                                if v2.0 == v11.0 {
                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let v140 = C::unpack_value_array_2(ctx, v139);
                                                                    if v104.0 == v140.0 {
                                                                        if v104.1 == v140.1 {
                                                                            let v284 = constructor_smin(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 425.
                                                                            returns.extend(Some(v284));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        if v104.1 == v140.0 {
                                                                            let v284 = constructor_smin(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 426.
                                                                            returns.extend(Some(v284));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Umin => {
                                                                if v2.0 == v11.0 {
                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let v140 = C::unpack_value_array_2(ctx, v139);
                                                                    if v104.0 == v140.0 {
                                                                        if v104.1 == v140.1 {
                                                                            let v284 = constructor_smin(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 427.
                                                                            returns.extend(Some(v284));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        if v104.1 == v140.0 {
                                                                            let v284 = constructor_smin(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 428.
                                                                            returns.extend(Some(v284));
                                                                            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 v1816 = C::lane_type(ctx, v2.0);
                                                            let v1979 = constructor_smin(ctx, v1816, v30, v27);
                                                            let v1980 = constructor_splat(ctx, v2.0, v1979);
                                                            // Rule at src/opts/vector.isle line 54.
                                                            returns.extend(Some(v1980));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v22,
                                    imm: v23,
                                } => {
                                    if let &Opcode::Iconst = v22 {
                                        let v292 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v293) = v292 {
                                            if v19.0 == v293 {
                                                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 v967 = C::imm64_smin(ctx, v293, v23, v15);
                                                                let v968 = constructor_iconst(ctx, v293, v967);
                                                                let v969 = C::subsume(ctx, v968);
                                                                // Rule at src/opts/cprop.isle line 113.
                                                                returns.extend(Some(v969));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        if v2.0 == v19.0 {
                                            let v999 = constructor_smin(ctx, v2.0, v7.1, v7.0);
                                            // Rule at src/opts/cprop.isle line 168.
                                            returns.extend(Some(v999));
                                            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) {
                            if let &InstructionData::Binary {
                                opcode: ref v138,
                                args: ref v139,
                            } = &v11.1 {
                                match v138 {
                                    &Opcode::Smin => {
                                        if v2.0 == v11.0 {
                                            let v140 = C::unpack_value_array_2(ctx, v139);
                                            if v7.0 == v140.0 {
                                                let v286 = constructor_smin(ctx, v2.0, v7.0, v140.1);
                                                // Rule at src/opts/arithmetic.isle line 389.
                                                returns.extend(Some(v286));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            if v7.0 == v140.1 {
                                                let v287 = constructor_smin(ctx, v2.0, v7.0, v140.0);
                                                // Rule at src/opts/arithmetic.isle line 390.
                                                returns.extend(Some(v287));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                    &Opcode::Smax => {
                                        if v2.0 == v11.0 {
                                            let v140 = C::unpack_value_array_2(ctx, v139);
                                            if v7.0 == v140.0 {
                                                // Rule at src/opts/arithmetic.isle line 400.
                                                returns.extend(Some(v7.0));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            if v7.0 == v140.1 {
                                                // Rule at src/opts/arithmetic.isle line 399.
                                                returns.extend(Some(v7.0));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                        }
                        if v7.0 == v7.1 {
                            // Rule at src/opts/arithmetic.isle line 372.
                            returns.extend(Some(v7.0));
                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                        }
                    }
                    &Opcode::Umin => {
                        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 v102,
                                    args: ref v103,
                                } => {
                                    match v102 {
                                        &Opcode::Smin => {
                                            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 v138,
                                                        args: ref v139,
                                                    } = &v11.1 {
                                                        match v138 {
                                                            &Opcode::Smax => {
                                                                if v2.0 == v11.0 {
                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let v140 = C::unpack_value_array_2(ctx, v139);
                                                                    if v104.0 == v140.0 {
                                                                        if v104.1 == v140.1 {
                                                                            let v288 = constructor_umin(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 440.
                                                                            returns.extend(Some(v288));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        if v104.1 == v140.0 {
                                                                            let v288 = constructor_umin(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 441.
                                                                            returns.extend(Some(v288));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Umax => {
                                                                if v2.0 == v11.0 {
                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let v140 = C::unpack_value_array_2(ctx, v139);
                                                                    if v104.0 == v140.0 {
                                                                        if v104.1 == v140.1 {
                                                                            let v284 = constructor_smin(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 442.
                                                                            returns.extend(Some(v284));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        if v104.1 == v140.0 {
                                                                            let v284 = constructor_smin(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 443.
                                                                            returns.extend(Some(v284));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Umin => {
                                            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 v138,
                                                            args: ref v139,
                                                        } => {
                                                            match v138 {
                                                                &Opcode::Smax => {
                                                                    if v2.0 == v11.0 {
                                                                        let v104 = C::unpack_value_array_2(ctx, v103);
                                                                        let v140 = C::unpack_value_array_2(ctx, v139);
                                                                        if v104.0 == v140.0 {
                                                                            if v104.1 == v140.1 {
                                                                                let v288 = constructor_umin(ctx, v2.0, v104.0, v104.1);
                                                                                // Rule at src/opts/arithmetic.isle line 450.
                                                                                returns.extend(Some(v288));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                        if v104.0 == v140.1 {
                                                                            if v104.1 == v140.0 {
                                                                                let v288 = constructor_umin(ctx, v2.0, v104.0, v104.1);
                                                                                // Rule at src/opts/arithmetic.isle line 451.
                                                                                returns.extend(Some(v288));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Umax => {
                                                                    if v2.0 == v11.0 {
                                                                        let v104 = C::unpack_value_array_2(ctx, v103);
                                                                        let v140 = C::unpack_value_array_2(ctx, v139);
                                                                        if v104.0 == v140.0 {
                                                                            if v104.1 == v140.1 {
                                                                                let v288 = constructor_umin(ctx, v2.0, v104.0, v104.1);
                                                                                // Rule at src/opts/arithmetic.isle line 452.
                                                                                returns.extend(Some(v288));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                        if v104.0 == v140.1 {
                                                                            if v104.1 == v140.0 {
                                                                                let v288 = constructor_umin(ctx, v2.0, v104.0, v104.1);
                                                                                // Rule at src/opts/arithmetic.isle line 453.
                                                                                returns.extend(Some(v288));
                                                                                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 v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let mut v114 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                                    let mut v114 = v114.into_context_iter();
                                                                    while let Some(v115) = v114.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v132,
                                                                            imm: v133,
                                                                        } = &v115.1 {
                                                                            if let &Opcode::Iconst = v132 {
                                                                                if v2.0 == v115.0 {
                                                                                    let v1037 = constructor_umin(ctx, v2.0, v104.1, v7.1);
                                                                                    let v1038 = constructor_umin(ctx, v2.0, v104.0, v1037);
                                                                                    // Rule at src/opts/cprop.isle line 231.
                                                                                    returns.extend(Some(v1038));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let v104 = C::unpack_value_array_2(ctx, v103);
                                                if v7.1 == v104.0 {
                                                    let v288 = constructor_umin(ctx, v2.0, v104.0, v104.1);
                                                    // Rule at src/opts/arithmetic.isle line 391.
                                                    returns.extend(Some(v288));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.1 == v104.1 {
                                                    let v289 = constructor_umin(ctx, v2.0, v104.1, v104.0);
                                                    // Rule at src/opts/arithmetic.isle line 392.
                                                    returns.extend(Some(v289));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        &Opcode::Smax => {
                                            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 v138,
                                                        args: ref v139,
                                                    } = &v11.1 {
                                                        match v138 {
                                                            &Opcode::Smin => {
                                                                if v2.0 == v11.0 {
                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let v140 = C::unpack_value_array_2(ctx, v139);
                                                                    if v104.0 == v140.0 {
                                                                        if v104.1 == v140.1 {
                                                                            let v288 = constructor_umin(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 435.
                                                                            returns.extend(Some(v288));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        if v104.1 == v140.0 {
                                                                            let v288 = constructor_umin(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 436.
                                                                            returns.extend(Some(v288));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Umin => {
                                                                if v2.0 == v11.0 {
                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let v140 = C::unpack_value_array_2(ctx, v139);
                                                                    if v104.0 == v140.0 {
                                                                        if v104.1 == v140.1 {
                                                                            let v288 = constructor_umin(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 437.
                                                                            returns.extend(Some(v288));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        if v104.1 == v140.0 {
                                                                            let v288 = constructor_umin(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 438.
                                                                            returns.extend(Some(v288));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Umax => {
                                            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 v138,
                                                        args: ref v139,
                                                    } = &v11.1 {
                                                        match v138 {
                                                            &Opcode::Smin => {
                                                                if v2.0 == v11.0 {
                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let v140 = C::unpack_value_array_2(ctx, v139);
                                                                    if v104.0 == v140.0 {
                                                                        if v104.1 == v140.1 {
                                                                            let v284 = constructor_smin(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 445.
                                                                            returns.extend(Some(v284));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        if v104.1 == v140.0 {
                                                                            let v284 = constructor_smin(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 446.
                                                                            returns.extend(Some(v284));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Umin => {
                                                                if v2.0 == v11.0 {
                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let v140 = C::unpack_value_array_2(ctx, v139);
                                                                    if v104.0 == v140.0 {
                                                                        if v104.1 == v140.1 {
                                                                            let v288 = constructor_umin(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 447.
                                                                            returns.extend(Some(v288));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        if v104.1 == v140.0 {
                                                                            let v288 = constructor_umin(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 448.
                                                                            returns.extend(Some(v288));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                    }
                                                }
                                                let v104 = C::unpack_value_array_2(ctx, v103);
                                                if v7.1 == v104.0 {
                                                    // Rule at src/opts/arithmetic.isle line 402.
                                                    returns.extend(Some(v104.0));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.1 == v104.1 {
                                                    // Rule at src/opts/arithmetic.isle line 401.
                                                    returns.extend(Some(v104.1));
                                                    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 v1816 = C::lane_type(ctx, v2.0);
                                                            let v1981 = constructor_umin(ctx, v1816, v30, v27);
                                                            let v1982 = constructor_splat(ctx, v2.0, v1981);
                                                            // Rule at src/opts/vector.isle line 57.
                                                            returns.extend(Some(v1982));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v22,
                                    imm: v23,
                                } => {
                                    if let &Opcode::Iconst = v22 {
                                        let v292 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v293) = v292 {
                                            if v19.0 == v293 {
                                                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 v961 = C::imm64_umin(ctx, v293, v23, v15);
                                                                let v962 = constructor_iconst(ctx, v293, v961);
                                                                let v963 = C::subsume(ctx, v962);
                                                                // Rule at src/opts/cprop.isle line 103.
                                                                returns.extend(Some(v963));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        if v2.0 == v19.0 {
                                            let v1000 = constructor_umin(ctx, v2.0, v7.1, v7.0);
                                            // Rule at src/opts/cprop.isle line 169.
                                            returns.extend(Some(v1000));
                                            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) {
                            if let &InstructionData::Binary {
                                opcode: ref v138,
                                args: ref v139,
                            } = &v11.1 {
                                match v138 {
                                    &Opcode::Umin => {
                                        if v2.0 == v11.0 {
                                            let v140 = C::unpack_value_array_2(ctx, v139);
                                            if v7.0 == v140.0 {
                                                let v290 = constructor_umin(ctx, v2.0, v7.0, v140.1);
                                                // Rule at src/opts/arithmetic.isle line 393.
                                                returns.extend(Some(v290));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            if v7.0 == v140.1 {
                                                let v291 = constructor_umin(ctx, v2.0, v7.0, v140.0);
                                                // Rule at src/opts/arithmetic.isle line 394.
                                                returns.extend(Some(v291));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                    &Opcode::Umax => {
                                        if v2.0 == v11.0 {
                                            let v140 = C::unpack_value_array_2(ctx, v139);
                                            if v7.0 == v140.0 {
                                                // Rule at src/opts/arithmetic.isle line 404.
                                                returns.extend(Some(v7.0));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            if v7.0 == v140.1 {
                                                // Rule at src/opts/arithmetic.isle line 403.
                                                returns.extend(Some(v7.0));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                        }
                        if v7.0 == v7.1 {
                            // Rule at src/opts/arithmetic.isle line 371.
                            returns.extend(Some(v7.0));
                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                        }
                    }
                    &Opcode::Smax => {
                        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 v102,
                                    args: ref v103,
                                } => {
                                    match v102 {
                                        &Opcode::Smin => {
                                            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 v138,
                                                        args: ref v139,
                                                    } = &v11.1 {
                                                        match v138 {
                                                            &Opcode::Smax => {
                                                                if v2.0 == v11.0 {
                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let v140 = C::unpack_value_array_2(ctx, v139);
                                                                    if v104.0 == v140.0 {
                                                                        if v104.1 == v140.1 {
                                                                            let v276 = constructor_smax(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 461.
                                                                            returns.extend(Some(v276));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        if v104.1 == v140.0 {
                                                                            let v276 = constructor_smax(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 462.
                                                                            returns.extend(Some(v276));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Umax => {
                                                                if v2.0 == v11.0 {
                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let v140 = C::unpack_value_array_2(ctx, v139);
                                                                    if v104.0 == v140.0 {
                                                                        if v104.1 == v140.1 {
                                                                            let v280 = constructor_umax(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 463.
                                                                            returns.extend(Some(v280));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        if v104.1 == v140.0 {
                                                                            let v280 = constructor_umax(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 464.
                                                                            returns.extend(Some(v280));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                    }
                                                }
                                                let v104 = C::unpack_value_array_2(ctx, v103);
                                                if v7.1 == v104.0 {
                                                    // Rule at src/opts/arithmetic.isle line 406.
                                                    returns.extend(Some(v104.0));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.1 == v104.1 {
                                                    // Rule at src/opts/arithmetic.isle line 405.
                                                    returns.extend(Some(v104.1));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        &Opcode::Umin => {
                                            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 v138,
                                                        args: ref v139,
                                                    } = &v11.1 {
                                                        match v138 {
                                                            &Opcode::Smax => {
                                                                if v2.0 == v11.0 {
                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let v140 = C::unpack_value_array_2(ctx, v139);
                                                                    if v104.0 == v140.0 {
                                                                        if v104.1 == v140.1 {
                                                                            let v276 = constructor_smax(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 471.
                                                                            returns.extend(Some(v276));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        if v104.1 == v140.0 {
                                                                            let v276 = constructor_smax(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 472.
                                                                            returns.extend(Some(v276));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Umax => {
                                                                if v2.0 == v11.0 {
                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let v140 = C::unpack_value_array_2(ctx, v139);
                                                                    if v104.0 == v140.0 {
                                                                        if v104.1 == v140.1 {
                                                                            let v276 = constructor_smax(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 473.
                                                                            returns.extend(Some(v276));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        if v104.1 == v140.0 {
                                                                            let v276 = constructor_smax(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 474.
                                                                            returns.extend(Some(v276));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Smax => {
                                            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 v138,
                                                            args: ref v139,
                                                        } => {
                                                            match v138 {
                                                                &Opcode::Smin => {
                                                                    if v2.0 == v11.0 {
                                                                        let v104 = C::unpack_value_array_2(ctx, v103);
                                                                        let v140 = C::unpack_value_array_2(ctx, v139);
                                                                        if v104.0 == v140.0 {
                                                                            if v104.1 == v140.1 {
                                                                                let v276 = constructor_smax(ctx, v2.0, v104.0, v104.1);
                                                                                // Rule at src/opts/arithmetic.isle line 456.
                                                                                returns.extend(Some(v276));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                        if v104.0 == v140.1 {
                                                                            if v104.1 == v140.0 {
                                                                                let v276 = constructor_smax(ctx, v2.0, v104.0, v104.1);
                                                                                // Rule at src/opts/arithmetic.isle line 457.
                                                                                returns.extend(Some(v276));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Umin => {
                                                                    if v2.0 == v11.0 {
                                                                        let v104 = C::unpack_value_array_2(ctx, v103);
                                                                        let v140 = C::unpack_value_array_2(ctx, v139);
                                                                        if v104.0 == v140.0 {
                                                                            if v104.1 == v140.1 {
                                                                                let v276 = constructor_smax(ctx, v2.0, v104.0, v104.1);
                                                                                // Rule at src/opts/arithmetic.isle line 458.
                                                                                returns.extend(Some(v276));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                        if v104.0 == v140.1 {
                                                                            if v104.1 == v140.0 {
                                                                                let v276 = constructor_smax(ctx, v2.0, v104.0, v104.1);
                                                                                // Rule at src/opts/arithmetic.isle line 459.
                                                                                returns.extend(Some(v276));
                                                                                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 v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let mut v114 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                                    let mut v114 = v114.into_context_iter();
                                                                    while let Some(v115) = v114.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v132,
                                                                            imm: v133,
                                                                        } = &v115.1 {
                                                                            if let &Opcode::Iconst = v132 {
                                                                                if v2.0 == v115.0 {
                                                                                    let v1043 = constructor_smax(ctx, v2.0, v104.1, v7.1);
                                                                                    let v1044 = constructor_smax(ctx, v2.0, v104.0, v1043);
                                                                                    // Rule at src/opts/cprop.isle line 240.
                                                                                    returns.extend(Some(v1044));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let v104 = C::unpack_value_array_2(ctx, v103);
                                                if v7.1 == v104.0 {
                                                    let v276 = constructor_smax(ctx, v2.0, v104.0, v104.1);
                                                    // Rule at src/opts/arithmetic.isle line 377.
                                                    returns.extend(Some(v276));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.1 == v104.1 {
                                                    let v277 = constructor_smax(ctx, v2.0, v104.1, v104.0);
                                                    // Rule at src/opts/arithmetic.isle line 378.
                                                    returns.extend(Some(v277));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        &Opcode::Umax => {
                                            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 v138,
                                                        args: ref v139,
                                                    } = &v11.1 {
                                                        match v138 {
                                                            &Opcode::Smin => {
                                                                if v2.0 == v11.0 {
                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let v140 = C::unpack_value_array_2(ctx, v139);
                                                                    if v104.0 == v140.0 {
                                                                        if v104.1 == v140.1 {
                                                                            let v280 = constructor_umax(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 466.
                                                                            returns.extend(Some(v280));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        if v104.1 == v140.0 {
                                                                            let v280 = constructor_umax(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 467.
                                                                            returns.extend(Some(v280));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Umin => {
                                                                if v2.0 == v11.0 {
                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let v140 = C::unpack_value_array_2(ctx, v139);
                                                                    if v104.0 == v140.0 {
                                                                        if v104.1 == v140.1 {
                                                                            let v276 = constructor_smax(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 468.
                                                                            returns.extend(Some(v276));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        if v104.1 == v140.0 {
                                                                            let v276 = constructor_smax(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 469.
                                                                            returns.extend(Some(v276));
                                                                            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 v1816 = C::lane_type(ctx, v2.0);
                                                            let v1983 = constructor_smax(ctx, v1816, v30, v27);
                                                            let v1984 = constructor_splat(ctx, v2.0, v1983);
                                                            // Rule at src/opts/vector.isle line 60.
                                                            returns.extend(Some(v1984));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v22,
                                    imm: v23,
                                } => {
                                    if let &Opcode::Iconst = v22 {
                                        let v292 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v293) = v292 {
                                            if v19.0 == v293 {
                                                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 v970 = C::imm64_smax(ctx, v293, v23, v15);
                                                                let v971 = constructor_iconst(ctx, v293, v970);
                                                                let v972 = C::subsume(ctx, v971);
                                                                // Rule at src/opts/cprop.isle line 118.
                                                                returns.extend(Some(v972));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        if v2.0 == v19.0 {
                                            let v1001 = constructor_smax(ctx, v2.0, v7.1, v7.0);
                                            // Rule at src/opts/cprop.isle line 170.
                                            returns.extend(Some(v1001));
                                            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) {
                            if let &InstructionData::Binary {
                                opcode: ref v138,
                                args: ref v139,
                            } = &v11.1 {
                                match v138 {
                                    &Opcode::Smin => {
                                        if v2.0 == v11.0 {
                                            let v140 = C::unpack_value_array_2(ctx, v139);
                                            if v7.0 == v140.0 {
                                                // Rule at src/opts/arithmetic.isle line 408.
                                                returns.extend(Some(v7.0));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            if v7.0 == v140.1 {
                                                // Rule at src/opts/arithmetic.isle line 407.
                                                returns.extend(Some(v7.0));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                    &Opcode::Smax => {
                                        if v2.0 == v11.0 {
                                            let v140 = C::unpack_value_array_2(ctx, v139);
                                            if v7.0 == v140.0 {
                                                let v278 = constructor_smax(ctx, v2.0, v7.0, v140.1);
                                                // Rule at src/opts/arithmetic.isle line 379.
                                                returns.extend(Some(v278));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            if v7.0 == v140.1 {
                                                let v279 = constructor_smax(ctx, v2.0, v7.0, v140.0);
                                                // Rule at src/opts/arithmetic.isle line 380.
                                                returns.extend(Some(v279));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                        }
                        if v7.0 == v7.1 {
                            // Rule at src/opts/arithmetic.isle line 374.
                            returns.extend(Some(v7.0));
                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                        }
                    }
                    &Opcode::Umax => {
                        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 v102,
                                    args: ref v103,
                                } => {
                                    match v102 {
                                        &Opcode::Smin => {
                                            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 v138,
                                                        args: ref v139,
                                                    } = &v11.1 {
                                                        match v138 {
                                                            &Opcode::Smax => {
                                                                if v2.0 == v11.0 {
                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let v140 = C::unpack_value_array_2(ctx, v139);
                                                                    if v104.0 == v140.0 {
                                                                        if v104.1 == v140.1 {
                                                                            let v280 = constructor_umax(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 481.
                                                                            returns.extend(Some(v280));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        if v104.1 == v140.0 {
                                                                            let v280 = constructor_umax(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 482.
                                                                            returns.extend(Some(v280));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Umax => {
                                                                if v2.0 == v11.0 {
                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let v140 = C::unpack_value_array_2(ctx, v139);
                                                                    if v104.0 == v140.0 {
                                                                        if v104.1 == v140.1 {
                                                                            let v280 = constructor_umax(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 483.
                                                                            returns.extend(Some(v280));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        if v104.1 == v140.0 {
                                                                            let v280 = constructor_umax(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 484.
                                                                            returns.extend(Some(v280));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Umin => {
                                            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 v138,
                                                        args: ref v139,
                                                    } = &v11.1 {
                                                        match v138 {
                                                            &Opcode::Smax => {
                                                                if v2.0 == v11.0 {
                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let v140 = C::unpack_value_array_2(ctx, v139);
                                                                    if v104.0 == v140.0 {
                                                                        if v104.1 == v140.1 {
                                                                            let v276 = constructor_smax(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 491.
                                                                            returns.extend(Some(v276));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        if v104.1 == v140.0 {
                                                                            let v276 = constructor_smax(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 492.
                                                                            returns.extend(Some(v276));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Umax => {
                                                                if v2.0 == v11.0 {
                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let v140 = C::unpack_value_array_2(ctx, v139);
                                                                    if v104.0 == v140.0 {
                                                                        if v104.1 == v140.1 {
                                                                            let v280 = constructor_umax(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 493.
                                                                            returns.extend(Some(v280));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        if v104.1 == v140.0 {
                                                                            let v280 = constructor_umax(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 494.
                                                                            returns.extend(Some(v280));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                    }
                                                }
                                                let v104 = C::unpack_value_array_2(ctx, v103);
                                                if v7.1 == v104.0 {
                                                    // Rule at src/opts/arithmetic.isle line 410.
                                                    returns.extend(Some(v104.0));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.1 == v104.1 {
                                                    // Rule at src/opts/arithmetic.isle line 409.
                                                    returns.extend(Some(v104.1));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        &Opcode::Smax => {
                                            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 v138,
                                                        args: ref v139,
                                                    } = &v11.1 {
                                                        match v138 {
                                                            &Opcode::Smin => {
                                                                if v2.0 == v11.0 {
                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let v140 = C::unpack_value_array_2(ctx, v139);
                                                                    if v104.0 == v140.0 {
                                                                        if v104.1 == v140.1 {
                                                                            let v280 = constructor_umax(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 476.
                                                                            returns.extend(Some(v280));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        if v104.1 == v140.0 {
                                                                            let v280 = constructor_umax(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 477.
                                                                            returns.extend(Some(v280));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Umin => {
                                                                if v2.0 == v11.0 {
                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let v140 = C::unpack_value_array_2(ctx, v139);
                                                                    if v104.0 == v140.0 {
                                                                        if v104.1 == v140.1 {
                                                                            let v276 = constructor_smax(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 478.
                                                                            returns.extend(Some(v276));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        if v104.1 == v140.0 {
                                                                            let v276 = constructor_smax(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 479.
                                                                            returns.extend(Some(v276));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Umax => {
                                            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 v138,
                                                            args: ref v139,
                                                        } => {
                                                            match v138 {
                                                                &Opcode::Smin => {
                                                                    if v2.0 == v11.0 {
                                                                        let v104 = C::unpack_value_array_2(ctx, v103);
                                                                        let v140 = C::unpack_value_array_2(ctx, v139);
                                                                        if v104.0 == v140.0 {
                                                                            if v104.1 == v140.1 {
                                                                                let v280 = constructor_umax(ctx, v2.0, v104.0, v104.1);
                                                                                // Rule at src/opts/arithmetic.isle line 486.
                                                                                returns.extend(Some(v280));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                        if v104.0 == v140.1 {
                                                                            if v104.1 == v140.0 {
                                                                                let v280 = constructor_umax(ctx, v2.0, v104.0, v104.1);
                                                                                // Rule at src/opts/arithmetic.isle line 487.
                                                                                returns.extend(Some(v280));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Umin => {
                                                                    if v2.0 == v11.0 {
                                                                        let v104 = C::unpack_value_array_2(ctx, v103);
                                                                        let v140 = C::unpack_value_array_2(ctx, v139);
                                                                        if v104.0 == v140.0 {
                                                                            if v104.1 == v140.1 {
                                                                                let v280 = constructor_umax(ctx, v2.0, v104.0, v104.1);
                                                                                // Rule at src/opts/arithmetic.isle line 488.
                                                                                returns.extend(Some(v280));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                        if v104.0 == v140.1 {
                                                                            if v104.1 == v140.0 {
                                                                                let v280 = constructor_umax(ctx, v2.0, v104.0, v104.1);
                                                                                // Rule at src/opts/arithmetic.isle line 489.
                                                                                returns.extend(Some(v280));
                                                                                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 v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let mut v114 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                                    let mut v114 = v114.into_context_iter();
                                                                    while let Some(v115) = v114.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v132,
                                                                            imm: v133,
                                                                        } = &v115.1 {
                                                                            if let &Opcode::Iconst = v132 {
                                                                                if v2.0 == v115.0 {
                                                                                    let v1039 = constructor_umax(ctx, v2.0, v104.1, v7.1);
                                                                                    let v1040 = constructor_umax(ctx, v2.0, v104.0, v1039);
                                                                                    // Rule at src/opts/cprop.isle line 234.
                                                                                    returns.extend(Some(v1040));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let v104 = C::unpack_value_array_2(ctx, v103);
                                                if v7.1 == v104.0 {
                                                    let v280 = constructor_umax(ctx, v2.0, v104.0, v104.1);
                                                    // Rule at src/opts/arithmetic.isle line 381.
                                                    returns.extend(Some(v280));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.1 == v104.1 {
                                                    let v281 = constructor_umax(ctx, v2.0, v104.1, v104.0);
                                                    // Rule at src/opts/arithmetic.isle line 382.
                                                    returns.extend(Some(v281));
                                                    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 v1816 = C::lane_type(ctx, v2.0);
                                                            let v1985 = constructor_umax(ctx, v1816, v30, v27);
                                                            let v1986 = constructor_splat(ctx, v2.0, v1985);
                                                            // Rule at src/opts/vector.isle line 63.
                                                            returns.extend(Some(v1986));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v22,
                                    imm: v23,
                                } => {
                                    if let &Opcode::Iconst = v22 {
                                        let v292 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v293) = v292 {
                                            if v19.0 == v293 {
                                                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 v964 = C::imm64_umax(ctx, v293, v23, v15);
                                                                let v965 = constructor_iconst(ctx, v293, v964);
                                                                let v966 = C::subsume(ctx, v965);
                                                                // Rule at src/opts/cprop.isle line 108.
                                                                returns.extend(Some(v966));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        if v2.0 == v19.0 {
                                            let v1002 = constructor_umax(ctx, v2.0, v7.1, v7.0);
                                            // Rule at src/opts/cprop.isle line 171.
                                            returns.extend(Some(v1002));
                                            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) {
                            if let &InstructionData::Binary {
                                opcode: ref v138,
                                args: ref v139,
                            } = &v11.1 {
                                match v138 {
                                    &Opcode::Umin => {
                                        if v2.0 == v11.0 {
                                            let v140 = C::unpack_value_array_2(ctx, v139);
                                            if v7.0 == v140.0 {
                                                // Rule at src/opts/arithmetic.isle line 412.
                                                returns.extend(Some(v7.0));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            if v7.0 == v140.1 {
                                                // Rule at src/opts/arithmetic.isle line 411.
                                                returns.extend(Some(v7.0));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                    &Opcode::Umax => {
                                        if v2.0 == v11.0 {
                                            let v140 = C::unpack_value_array_2(ctx, v139);
                                            if v7.0 == v140.0 {
                                                let v282 = constructor_umax(ctx, v2.0, v7.0, v140.1);
                                                // Rule at src/opts/arithmetic.isle line 383.
                                                returns.extend(Some(v282));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            if v7.0 == v140.1 {
                                                let v283 = constructor_umax(ctx, v2.0, v7.0, v140.0);
                                                // Rule at src/opts/arithmetic.isle line 384.
                                                returns.extend(Some(v283));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                        }
                        if v7.0 == v7.1 {
                            // Rule at src/opts/arithmetic.isle line 373.
                            returns.extend(Some(v7.0));
                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                        }
                    }
                    &Opcode::Iadd => {
                        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 v138,
                                    args: ref v139,
                                } => {
                                    match v138 {
                                        &Opcode::Iadd => {
                                            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) {
                                                    match &v19.1 {
                                                        &InstructionData::Binary {
                                                            opcode: ref v102,
                                                            args: ref v103,
                                                        } => {
                                                            if let &Opcode::Iadd = v102 {
                                                                if v2.0 == v19.0 {
                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let mut v114 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                                    let mut v114 = v114.into_context_iter();
                                                                    while let Some(v115) = v114.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v132,
                                                                            imm: v133,
                                                                        } = &v115.1 {
                                                                            if let &Opcode::Iconst = v132 {
                                                                                let v140 = C::unpack_value_array_2(ctx, v139);
                                                                                let mut v414 = C::inst_data_value_etor_returns::default();
                                                                                C::inst_data_value_etor(ctx, v140.1, &mut v414);
                                                                                let mut v414 = v414.into_context_iter();
                                                                                while let Some(v415) = v414.next(ctx) {
                                                                                    if let &InstructionData::UnaryImm {
                                                                                        opcode: ref v1097,
                                                                                        imm: v1098,
                                                                                    } = &v415.1 {
                                                                                        if let &Opcode::Iconst = v1097 {
                                                                                            let v1099 = constructor_iadd(ctx, v2.0, v104.0, v140.0);
                                                                                            let v1100 = constructor_iadd(ctx, v2.0, v104.1, v140.1);
                                                                                            let v1101 = constructor_iadd(ctx, v2.0, v1099, v1100);
                                                                                            // Rule at src/opts/cprop.isle line 313.
                                                                                            returns.extend(Some(v1101));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v29,
                                                            arg: v30,
                                                        } => {
                                                            if let &Opcode::Ineg = v29 {
                                                                if v2.0 == v19.0 {
                                                                    let v140 = C::unpack_value_array_2(ctx, v139);
                                                                    if v30 == v140.0 {
                                                                        // Rule at src/opts/arithmetic.isle line 299.
                                                                        returns.extend(Some(v140.1));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v30 == v140.1 {
                                                                        // Rule at src/opts/arithmetic.isle line 297.
                                                                        returns.extend(Some(v140.0));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Isub => {
                                            if v2.0 == v11.0 {
                                                let v140 = C::unpack_value_array_2(ctx, v139);
                                                if v7.0 == v140.1 {
                                                    // Rule at src/opts/arithmetic.isle line 241.
                                                    returns.extend(Some(v140.0));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        &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 v102,
                                                        args: ref v103,
                                                    } = &v19.1 {
                                                        match v102 {
                                                            &Opcode::Bor => {
                                                                if v2.0 == v19.0 {
                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let v140 = C::unpack_value_array_2(ctx, v139);
                                                                    if v104.0 == v140.0 {
                                                                        if v104.1 == v140.1 {
                                                                            let v619 = constructor_iadd(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/bitops.isle line 208.
                                                                            returns.extend(Some(v619));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Bxor => {
                                                                if v2.0 == v19.0 {
                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let v140 = C::unpack_value_array_2(ctx, v139);
                                                                    if v104.0 == v140.0 {
                                                                        if v104.1 == v140.1 {
                                                                            let v245 = constructor_bor(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/bitops.isle line 205.
                                                                            returns.extend(Some(v245));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Bor => {
                                            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) {
                                                    match &v19.1 {
                                                        &InstructionData::Binary {
                                                            opcode: ref v102,
                                                            args: ref v103,
                                                        } => {
                                                            if let &Opcode::Band = v102 {
                                                                if v2.0 == v19.0 {
                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let v140 = C::unpack_value_array_2(ctx, v139);
                                                                    if v104.0 == v140.0 {
                                                                        if v104.1 == v140.1 {
                                                                            let v619 = constructor_iadd(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/bitops.isle line 209.
                                                                            returns.extend(Some(v619));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v29,
                                                            arg: v30,
                                                        } => {
                                                            if let &Opcode::Ineg = v29 {
                                                                if v2.0 == v19.0 {
                                                                    let v140 = C::unpack_value_array_2(ctx, v139);
                                                                    if v30 == v140.0 {
                                                                        let v622 = constructor_bnot(ctx, v2.0, v30);
                                                                        let v654 = constructor_band(ctx, v2.0, v140.1, v622);
                                                                        // Rule at src/opts/bitops.isle line 245.
                                                                        returns.extend(Some(v654));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v30 == v140.1 {
                                                                        let v622 = constructor_bnot(ctx, v2.0, v30);
                                                                        let v652 = constructor_band(ctx, v2.0, v140.0, v622);
                                                                        // Rule at src/opts/bitops.isle line 241.
                                                                        returns.extend(Some(v652));
                                                                        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 v102,
                                                        args: ref v103,
                                                    } = &v19.1 {
                                                        if let &Opcode::Band = v102 {
                                                            if v2.0 == v19.0 {
                                                                let v104 = C::unpack_value_array_2(ctx, v103);
                                                                let v140 = C::unpack_value_array_2(ctx, v139);
                                                                if v104.0 == v140.0 {
                                                                    if v104.1 == v140.1 {
                                                                        let v245 = constructor_bor(ctx, v2.0, v104.0, v104.1);
                                                                        // Rule at src/opts/bitops.isle line 204.
                                                                        returns.extend(Some(v245));
                                                                        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 v102,
                                                        args: ref v103,
                                                    } = &v19.1 {
                                                        if let &Opcode::Ishl = v102 {
                                                            if v2.0 == v19.0 {
                                                                let v104 = C::unpack_value_array_2(ctx, v103);
                                                                let v140 = C::unpack_value_array_2(ctx, v139);
                                                                if v104.1 == v140.1 {
                                                                    let v1099 = constructor_iadd(ctx, v2.0, v104.0, v140.0);
                                                                    let v1874 = constructor_ishl(ctx, v2.0, v1099, v104.1);
                                                                    // Rule at src/opts/shifts.isle line 314.
                                                                    returns.extend(Some(v1874));
                                                                    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 v1816 = C::lane_type(ctx, v2.0);
                                                                let v1963 = constructor_iadd(ctx, v1816, v30, v27);
                                                                let v1964 = constructor_splat(ctx, v2.0, v1963);
                                                                // Rule at src/opts/vector.isle line 30.
                                                                returns.extend(Some(v1964));
                                                                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::Binary {
                                                        opcode: ref v102,
                                                        args: ref v103,
                                                    } = &v19.1 {
                                                        match v102 {
                                                            &Opcode::Iadd => {
                                                                if v2.0 == v19.0 {
                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                    if v27 == v104.0 {
                                                                        // Rule at src/opts/arithmetic.isle line 298.
                                                                        returns.extend(Some(v104.1));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v27 == v104.1 {
                                                                        // Rule at src/opts/arithmetic.isle line 296.
                                                                        returns.extend(Some(v104.0));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Bor => {
                                                                if v2.0 == v19.0 {
                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                    if v27 == v104.0 {
                                                                        let v620 = constructor_bnot(ctx, v2.0, v104.0);
                                                                        let v653 = constructor_band(ctx, v2.0, v104.1, v620);
                                                                        // Rule at src/opts/bitops.isle line 243.
                                                                        returns.extend(Some(v653));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v27 == v104.1 {
                                                                        let v650 = constructor_bnot(ctx, v2.0, v104.1);
                                                                        let v651 = constructor_band(ctx, v2.0, v104.0, v650);
                                                                        // Rule at src/opts/bitops.isle line 239.
                                                                        returns.extend(Some(v651));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                    }
                                                }
                                                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; }
                                            }
                                        }
                                        &Opcode::Bnot => {
                                            if v2.0 == v11.0 {
                                                if v7.0 == v27 {
                                                    let v249 = constructor_iconst_s(ctx, v2.0, -1_i64);
                                                    // Rule at src/opts/arithmetic.isle line 321.
                                                    returns.extend(Some(v249));
                                                    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) {
                                                match &v19.1 {
                                                    &InstructionData::Binary {
                                                        opcode: ref v102,
                                                        args: ref v103,
                                                    } => {
                                                        match v102 {
                                                            &Opcode::Iadd => {
                                                                if v2.0 == v19.0 {
                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let mut v114 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                                    let mut v114 = v114.into_context_iter();
                                                                    while let Some(v115) = v114.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v132,
                                                                            imm: v133,
                                                                        } = &v115.1 {
                                                                            if let &Opcode::Iconst = v132 {
                                                                                if v2.0 == v115.0 {
                                                                                    let v1005 = constructor_iadd(ctx, v2.0, v104.1, v7.1);
                                                                                    let v1006 = constructor_iadd(ctx, v2.0, v104.0, v1005);
                                                                                    // Rule at src/opts/cprop.isle line 182.
                                                                                    returns.extend(Some(v1006));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Isub => {
                                                                if v2.0 == v19.0 {
                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let mut v107 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v104.0, &mut v107);
                                                                    let mut v107 = v107.into_context_iter();
                                                                    while let Some(v108) = v107.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v1010,
                                                                            imm: v1011,
                                                                        } = &v108.1 {
                                                                            if let &Opcode::Iconst = v1010 {
                                                                                if v2.0 == v108.0 {
                                                                                    let v1019 = C::imm64_add(ctx, v2.0, v1011, v15);
                                                                                    let v1020 = constructor_iconst(ctx, v2.0, v1019);
                                                                                    let v1021 = constructor_isub(ctx, v2.0, v1020, v104.1);
                                                                                    // Rule at src/opts/cprop.isle line 208.
                                                                                    returns.extend(Some(v1021));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    let mut v114 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                                    let mut v114 = v114.into_context_iter();
                                                                    while let Some(v115) = v114.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v132,
                                                                            imm: v133,
                                                                        } = &v115.1 {
                                                                            if let &Opcode::Iconst = v132 {
                                                                                if v2.0 == v115.0 {
                                                                                    let v1015 = C::imm64_sub(ctx, v2.0, v15, v133);
                                                                                    let v1016 = constructor_iconst(ctx, v2.0, v1015);
                                                                                    let v1018 = constructor_iadd(ctx, v2.0, v104.0, v1016);
                                                                                    // Rule at src/opts/cprop.isle line 204.
                                                                                    returns.extend(Some(v1018));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Bor => {
                                                                if v2.0 == v19.0 {
                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let mut v114 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                                    let mut v114 = v114.into_context_iter();
                                                                    while let Some(v115) = v114.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v132,
                                                                            imm: v133,
                                                                        } = &v115.1 {
                                                                            if let &Opcode::Iconst = v132 {
                                                                                if v2.0 == v115.0 {
                                                                                    let v134 = C::imm64_neg(ctx, v2.0, v133);
                                                                                    if v15 == v134 {
                                                                                        let v135 = C::imm64_not(ctx, v2.0, v133);
                                                                                        let v136 = constructor_iconst(ctx, v2.0, v135);
                                                                                        let v137 = constructor_band(ctx, v2.0, v104.0, v136);
                                                                                        // Rule at src/opts/arithmetic.isle line 227.
                                                                                        returns.extend(Some(v137));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                    }
                                                    &InstructionData::Ternary {
                                                        opcode: ref v1636,
                                                        args: ref v1637,
                                                    } => {
                                                        if let &Opcode::Select = v1636 {
                                                            if v2.0 == v19.0 {
                                                                let v1638 = C::unpack_value_array_3(ctx, v1637);
                                                                let mut v1642 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v1638.1, &mut v1642);
                                                                let mut v1642 = v1642.into_context_iter();
                                                                while let Some(v1643) = v1642.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v1646,
                                                                        imm: v1647,
                                                                    } = &v1643.1 {
                                                                        if let &Opcode::Iconst = v1646 {
                                                                            if v2.0 == v1643.0 {
                                                                                let mut v1648 = C::inst_data_value_etor_returns::default();
                                                                                C::inst_data_value_etor(ctx, v1638.2, &mut v1648);
                                                                                let mut v1648 = v1648.into_context_iter();
                                                                                while let Some(v1649) = v1648.next(ctx) {
                                                                                    if let &InstructionData::UnaryImm {
                                                                                        opcode: ref v1652,
                                                                                        imm: v1653,
                                                                                    } = &v1649.1 {
                                                                                        if let &Opcode::Iconst = v1652 {
                                                                                            if v2.0 == v1649.0 {
                                                                                                let v1654 = C::imm64_add(ctx, v2.0, v1647, v15);
                                                                                                let v1655 = constructor_iconst(ctx, v2.0, v1654);
                                                                                                let v1656 = C::imm64_add(ctx, v2.0, v1653, v15);
                                                                                                let v1657 = constructor_iconst(ctx, v2.0, v1656);
                                                                                                let v1658 = constructor_select(ctx, v2.0, v1638.0, v1655, v1657);
                                                                                                // Rule at src/opts/selects.isle line 95.
                                                                                                returns.extend(Some(v1658));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                    &InstructionData::Unary {
                                                        opcode: ref v29,
                                                        arg: v30,
                                                    } => {
                                                        if let &Opcode::Bnot = v29 {
                                                            let v16 = C::u64_from_imm64(ctx, v15);
                                                            if v16 == 0x1_u64 {
                                                                if v2.0 == v19.0 {
                                                                    let v63 = constructor_ineg(ctx, v2.0, v30);
                                                                    // Rule at src/opts/arithmetic.isle line 68.
                                                                    returns.extend(Some(v63));
                                                                    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/arithmetic.isle line 7.
                                                returns.extend(Some(v17));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        let v292 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v293) = v292 {
                                            if v11.0 == v293 {
                                                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 v925 = C::imm64_add(ctx, v293, v23, v15);
                                                                let v926 = constructor_iconst(ctx, v293, v925);
                                                                let v927 = C::subsume(ctx, v926);
                                                                // Rule at src/opts/cprop.isle line 13.
                                                                returns.extend(Some(v927));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        let v1572 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 5.
                                        returns.extend(Some(v1572));
                                        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 v102,
                                    args: ref v103,
                                } => {
                                    if let &Opcode::Isub = v102 {
                                        if v2.0 == v19.0 {
                                            let v104 = C::unpack_value_array_2(ctx, v103);
                                            if v7.1 == v104.1 {
                                                // Rule at src/opts/arithmetic.isle line 240.
                                                returns.extend(Some(v104.0));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v29,
                                    arg: v30,
                                } => {
                                    match v29 {
                                        &Opcode::Ineg => {
                                            if v2.0 == v19.0 {
                                                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 v7.1 == v30 {
                                                if v2.0 == v19.0 {
                                                    let v249 = constructor_iconst_s(ctx, v2.0, -1_i64);
                                                    // Rule at src/opts/arithmetic.isle line 320.
                                                    returns.extend(Some(v249));
                                                    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 v992 = constructor_iadd(ctx, v2.0, v7.1, v7.0);
                                            // Rule at src/opts/cprop.isle line 146.
                                            returns.extend(Some(v992));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        let v1572 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 3.
                                        returns.extend(Some(v1572));
                                        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 v102,
                                    args: ref v103,
                                } => {
                                    match v102 {
                                        &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 v138,
                                                            args: ref v139,
                                                        } => {
                                                            match v138 {
                                                                &Opcode::Band => {
                                                                    if v2.0 == v11.0 {
                                                                        let v104 = C::unpack_value_array_2(ctx, v103);
                                                                        let v140 = C::unpack_value_array_2(ctx, v139);
                                                                        if v104.0 == v140.0 {
                                                                            if v104.1 == v140.1 {
                                                                                let v245 = constructor_bor(ctx, v2.0, v104.0, v104.1);
                                                                                // Rule at src/opts/arithmetic.isle line 308.
                                                                                returns.extend(Some(v245));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                let v246 = constructor_bor(ctx, v2.0, v104.1, v104.0);
                                                                                // Rule at src/opts/arithmetic.isle line 311.
                                                                                returns.extend(Some(v246));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                        if v104.0 == v140.1 {
                                                                            if v104.1 == v140.0 {
                                                                                let v245 = constructor_bor(ctx, v2.0, v104.0, v104.1);
                                                                                // Rule at src/opts/arithmetic.isle line 309.
                                                                                returns.extend(Some(v245));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                let v246 = constructor_bor(ctx, v2.0, v104.1, v104.0);
                                                                                // Rule at src/opts/arithmetic.isle line 310.
                                                                                returns.extend(Some(v246));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Bor => {
                                                                    if v2.0 == v11.0 {
                                                                        let v104 = C::unpack_value_array_2(ctx, v103);
                                                                        let v140 = C::unpack_value_array_2(ctx, v139);
                                                                        if v104.0 == v140.0 {
                                                                            if v104.1 == v140.1 {
                                                                                let v143 = constructor_band(ctx, v2.0, v104.0, v104.1);
                                                                                // Rule at src/opts/arithmetic.isle line 234.
                                                                                returns.extend(Some(v143));
                                                                                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 v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let mut v114 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                                    let mut v114 = v114.into_context_iter();
                                                                    while let Some(v115) = v114.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v132,
                                                                            imm: v133,
                                                                        } = &v115.1 {
                                                                            if let &Opcode::Iconst = v132 {
                                                                                if v2.0 == v115.0 {
                                                                                    let v1015 = C::imm64_sub(ctx, v2.0, v15, v133);
                                                                                    let v1016 = constructor_iconst(ctx, v2.0, v1015);
                                                                                    let v1017 = constructor_isub(ctx, v2.0, v104.0, v1016);
                                                                                    // Rule at src/opts/cprop.isle line 200.
                                                                                    returns.extend(Some(v1017));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let v104 = C::unpack_value_array_2(ctx, v103);
                                                if v7.1 == v104.0 {
                                                    // Rule at src/opts/arithmetic.isle line 244.
                                                    returns.extend(Some(v104.1));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.1 == v104.1 {
                                                    // Rule at src/opts/arithmetic.isle line 245.
                                                    returns.extend(Some(v104.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 v104 = C::unpack_value_array_2(ctx, v103);
                                                                let mut v107 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v104.0, &mut v107);
                                                                let mut v107 = v107.into_context_iter();
                                                                while let Some(v108) = v107.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v1010,
                                                                        imm: v1011,
                                                                    } = &v108.1 {
                                                                        if let &Opcode::Iconst = v1010 {
                                                                            if v2.0 == v108.0 {
                                                                                let v1012 = C::imm64_sub(ctx, v2.0, v1011, v15);
                                                                                let v1013 = constructor_iconst(ctx, v2.0, v1012);
                                                                                let v1014 = constructor_isub(ctx, v2.0, v1013, v104.1);
                                                                                // Rule at src/opts/cprop.isle line 196.
                                                                                returns.extend(Some(v1014));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                let mut v114 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                                let mut v114 = v114.into_context_iter();
                                                                while let Some(v115) = v114.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v132,
                                                                        imm: v133,
                                                                    } = &v115.1 {
                                                                        if let &Opcode::Iconst = v132 {
                                                                            if v2.0 == v115.0 {
                                                                                let v1007 = C::imm64_add(ctx, v2.0, v133, v15);
                                                                                let v1008 = constructor_iconst(ctx, v2.0, v1007);
                                                                                let v1009 = constructor_isub(ctx, v2.0, v104.0, v1008);
                                                                                // Rule at src/opts/cprop.isle line 192.
                                                                                returns.extend(Some(v1009));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                let v104 = C::unpack_value_array_2(ctx, v103);
                                                if v7.1 == v104.0 {
                                                    let v151 = constructor_ineg(ctx, v2.0, v104.1);
                                                    // Rule at src/opts/arithmetic.isle line 248.
                                                    returns.extend(Some(v151));
                                                    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) {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v138,
                                                        args: ref v139,
                                                    } = &v11.1 {
                                                        match v138 {
                                                            &Opcode::Band => {
                                                                if v2.0 == v11.0 {
                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let v140 = C::unpack_value_array_2(ctx, v139);
                                                                    if v104.0 == v140.0 {
                                                                        if v104.1 == v140.1 {
                                                                            let v243 = constructor_bxor(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 302.
                                                                            returns.extend(Some(v243));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            let v244 = constructor_bxor(ctx, v2.0, v104.1, v104.0);
                                                                            // Rule at src/opts/arithmetic.isle line 305.
                                                                            returns.extend(Some(v244));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        if v104.1 == v140.0 {
                                                                            let v243 = constructor_bxor(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 303.
                                                                            returns.extend(Some(v243));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            let v244 = constructor_bxor(ctx, v2.0, v104.1, v104.0);
                                                                            // Rule at src/opts/arithmetic.isle line 304.
                                                                            returns.extend(Some(v244));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Bxor => {
                                                                if v2.0 == v11.0 {
                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let v140 = C::unpack_value_array_2(ctx, v139);
                                                                    if v104.0 == v140.0 {
                                                                        if v104.1 == v140.1 {
                                                                            let v143 = constructor_band(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 314.
                                                                            returns.extend(Some(v143));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            let v247 = constructor_band(ctx, v2.0, v104.1, v104.0);
                                                                            // Rule at src/opts/arithmetic.isle line 317.
                                                                            returns.extend(Some(v247));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        if v104.1 == v140.0 {
                                                                            let v143 = constructor_band(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 315.
                                                                            returns.extend(Some(v143));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            let v247 = constructor_band(ctx, v2.0, v104.1, v104.0);
                                                                            // Rule at src/opts/arithmetic.isle line 316.
                                                                            returns.extend(Some(v247));
                                                                            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 v138,
                                                        args: ref v139,
                                                    } = &v11.1 {
                                                        if let &Opcode::Ishl = v138 {
                                                            if v2.0 == v11.0 {
                                                                let v104 = C::unpack_value_array_2(ctx, v103);
                                                                let v140 = C::unpack_value_array_2(ctx, v139);
                                                                if v104.1 == v140.1 {
                                                                    let v1872 = constructor_isub(ctx, v2.0, v104.0, v140.0);
                                                                    let v1873 = constructor_ishl(ctx, v2.0, v1872, v104.1);
                                                                    // Rule at src/opts/shifts.isle line 313.
                                                                    returns.extend(Some(v1873));
                                                                    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 v1816 = C::lane_type(ctx, v2.0);
                                                                let v1965 = constructor_isub(ctx, v1816, v30, v27);
                                                                let v1966 = constructor_splat(ctx, v2.0, v1965);
                                                                // Rule at src/opts/vector.isle line 33.
                                                                returns.extend(Some(v1966));
                                                                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::Unary {
                                                        opcode: ref v26,
                                                        arg: v27,
                                                    } = &v11.1 {
                                                        if let &Opcode::Bnot = v26 {
                                                            if v2.0 == v11.0 {
                                                                let v897 = constructor_isub(ctx, v2.0, v27, v30);
                                                                // Rule at src/opts/bitops.isle line 612.
                                                                returns.extend(Some(v897));
                                                                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 v993 = constructor_isub(ctx, v2.0, v7.1, v7.0);
                                            let v994 = constructor_ineg(ctx, v2.0, v993);
                                            // Rule at src/opts/cprop.isle line 151.
                                            returns.extend(Some(v994));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        let v292 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v293) = v292 {
                                            if v19.0 == v293 {
                                                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 v928 = C::imm64_sub(ctx, v293, v23, v15);
                                                                let v929 = constructor_iconst(ctx, v293, v928);
                                                                let v930 = C::subsume(ctx, v929);
                                                                // Rule at src/opts/cprop.isle line 19.
                                                                returns.extend(Some(v930));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        let v1572 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 7.
                                        returns.extend(Some(v1572));
                                        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 v1572 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 9.
                                        returns.extend(Some(v1572));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                _ => {}
                            }
                        }
                        if v7.0 == v7.1 {
                            let v53 = constructor_iconst_u(ctx, v2.0, 0x0_u64);
                            let v54 = C::subsume(ctx, v53);
                            // Rule at src/opts/arithmetic.isle line 49.
                            returns.extend(Some(v54));
                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                        }
                        let mut v56 = C::inst_data_value_tupled_etor_returns::default();
                        C::inst_data_value_tupled_etor(ctx, v7.1, &mut v56);
                        let mut v56 = v56.into_context_iter();
                        while let Some(v57) = v56.next(ctx) {
                            let v58 = C::iconst_sextend_etor(ctx, v57);
                            if let Some(v59) = v58 {
                                let v1055 = C::i64_wrapping_neg(ctx, v59.1);
                                let v1056 = C::i64_cast_unsigned(ctx, v1055);
                                let v1057 = C::i64_cast_unsigned(ctx, v59.1);
                                let v1058 = C::u64_lt(ctx, v1056, v1057);
                                if v1058 == true {
                                    if v2.0 == v59.0 {
                                        let v1059 = C::imm64(ctx, v1057);
                                        let v1060 = C::imm64_neg(ctx, v2.0, v1059);
                                        let v1061 = constructor_iconst(ctx, v2.0, v1060);
                                        let v1062 = constructor_iadd(ctx, v2.0, v7.0, v1061);
                                        // Rule at src/opts/cprop.isle line 268.
                                        returns.extend(Some(v1062));
                                        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 v138,
                                    args: ref v139,
                                } => {
                                    match v138 {
                                        &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 v102,
                                                        args: ref v103,
                                                    } = &v19.1 {
                                                        if let &Opcode::Imul = v102 {
                                                            if v2.0 == v19.0 {
                                                                let v104 = C::unpack_value_array_2(ctx, v103);
                                                                let mut v114 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                                let mut v114 = v114.into_context_iter();
                                                                while let Some(v115) = v114.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v132,
                                                                        imm: v133,
                                                                    } = &v115.1 {
                                                                        if let &Opcode::Iconst = v132 {
                                                                            let v140 = C::unpack_value_array_2(ctx, v139);
                                                                            let mut v414 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v140.1, &mut v414);
                                                                            let mut v414 = v414.into_context_iter();
                                                                            while let Some(v415) = v414.next(ctx) {
                                                                                if let &InstructionData::UnaryImm {
                                                                                    opcode: ref v1097,
                                                                                    imm: v1098,
                                                                                } = &v415.1 {
                                                                                    if let &Opcode::Iconst = v1097 {
                                                                                        let v1102 = constructor_imul(ctx, v2.0, v104.0, v140.0);
                                                                                        let v1103 = constructor_imul(ctx, v2.0, v104.1, v140.1);
                                                                                        let v1104 = constructor_imul(ctx, v2.0, v1102, v1103);
                                                                                        // Rule at src/opts/cprop.isle line 317.
                                                                                        returns.extend(Some(v1104));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Ishl => {
                                            if v2.0 == v11.0 {
                                                let v140 = C::unpack_value_array_2(ctx, v139);
                                                let mut v144 = C::inst_data_value_tupled_etor_returns::default();
                                                C::inst_data_value_tupled_etor(ctx, v140.0, &mut v144);
                                                let mut v144 = v144.into_context_iter();
                                                while let Some(v145) = v144.next(ctx) {
                                                    let v146 = C::iconst_sextend_etor(ctx, v145);
                                                    if let Some(v147) = v146 {
                                                        if v147.1 == 1_i64 {
                                                            if v2.0 == v147.0 {
                                                                let v150 = constructor_ishl(ctx, v2.0, v7.0, v140.1);
                                                                // Rule at src/opts/arithmetic.isle line 237.
                                                                returns.extend(Some(v150));
                                                                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 v1816 = C::lane_type(ctx, v2.0);
                                                                let v1967 = constructor_imul(ctx, v1816, v30, v27);
                                                                let v1968 = constructor_splat(ctx, v2.0, v1967);
                                                                // Rule at src/opts/vector.isle line 36.
                                                                returns.extend(Some(v1968));
                                                                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 v55 = C::subsume(ctx, v7.1);
                                                    // Rule at src/opts/arithmetic.isle line 58.
                                                    returns.extend(Some(v55));
                                                    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 v71 = constructor_iadd(ctx, v2.0, v7.0, v7.0);
                                                // Rule at src/opts/arithmetic.isle line 172.
                                                returns.extend(Some(v71));
                                                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 v102,
                                                    args: ref v103,
                                                } => {
                                                    if let &Opcode::Imul = v102 {
                                                        if v2.0 == v11.0 {
                                                            if v2.0 == v19.0 {
                                                                let v104 = C::unpack_value_array_2(ctx, v103);
                                                                let mut v114 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                                let mut v114 = v114.into_context_iter();
                                                                while let Some(v115) = v114.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v132,
                                                                        imm: v133,
                                                                    } = &v115.1 {
                                                                        if let &Opcode::Iconst = v132 {
                                                                            if v2.0 == v115.0 {
                                                                                let v1022 = constructor_imul(ctx, v2.0, v104.1, v7.1);
                                                                                let v1023 = constructor_imul(ctx, v2.0, v104.0, v1022);
                                                                                // Rule at src/opts/cprop.isle line 213.
                                                                                returns.extend(Some(v1023));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                &InstructionData::Unary {
                                                    opcode: ref v29,
                                                    arg: v30,
                                                } => {
                                                    if let &Opcode::Ineg = v29 {
                                                        let v292 = C::fits_in_64(ctx, v2.0);
                                                        if let Some(v293) = v292 {
                                                            if v11.0 == v19.0 {
                                                                if v11.0 == v293 {
                                                                    let v294 = C::imm64_neg(ctx, v293, v15);
                                                                    let v295 = constructor_iconst(ctx, v293, v294);
                                                                    let v296 = constructor_imul(ctx, v293, v30, v295);
                                                                    // Rule at src/opts/arithmetic.isle line 507.
                                                                    returns.extend(Some(v296));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                &InstructionData::UnaryImm {
                                                    opcode: ref v22,
                                                    imm: v23,
                                                } => {
                                                    if let &Opcode::Iconst = v22 {
                                                        let v292 = C::fits_in_64(ctx, v2.0);
                                                        if let Some(v293) = v292 {
                                                            if v11.0 == v19.0 {
                                                                if v11.0 == v293 {
                                                                    let v931 = C::imm64_mul(ctx, v293, v23, v15);
                                                                    let v932 = constructor_iconst(ctx, v293, v931);
                                                                    let v933 = C::subsume(ctx, v932);
                                                                    // Rule at src/opts/cprop.isle line 25.
                                                                    returns.extend(Some(v933));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                _ => {}
                                            }
                                        }
                                        let v72 = C::imm64_power_of_two(ctx, v15);
                                        if let Some(v73) = v72 {
                                            let v74 = C::imm64(ctx, v73);
                                            let v75 = constructor_iconst(ctx, v2.0, v74);
                                            let v76 = constructor_ishl(ctx, v2.0, v7.0, v75);
                                            // Rule at src/opts/arithmetic.isle line 180.
                                            returns.extend(Some(v76));
                                            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 v77 = C::imm64_power_of_two(ctx, v23);
                                    if let Some(v78) = v77 {
                                        let v79 = C::imm64(ctx, v78);
                                        let v80 = constructor_iconst(ctx, v2.0, v79);
                                        let v81 = constructor_ishl(ctx, v2.0, v7.1, v80);
                                        // Rule at src/opts/arithmetic.isle line 182.
                                        returns.extend(Some(v81));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                    if v2.0 == v19.0 {
                                        let v995 = constructor_imul(ctx, v2.0, v7.1, v7.0);
                                        // Rule at src/opts/cprop.isle line 154.
                                        returns.extend(Some(v995));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                            }
                        }
                        let mut v56 = C::inst_data_value_tupled_etor_returns::default();
                        C::inst_data_value_tupled_etor(ctx, v7.1, &mut v56);
                        let mut v56 = v56.into_context_iter();
                        while let Some(v57) = v56.next(ctx) {
                            let v58 = C::iconst_sextend_etor(ctx, v57);
                            if let Some(v59) = v58 {
                                if v59.1 == -1_i64 {
                                    if v2.0 == v59.0 {
                                        let v62 = constructor_ineg(ctx, v2.0, v7.0);
                                        // Rule at src/opts/arithmetic.isle line 64.
                                        returns.extend(Some(v62));
                                        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 v1816 = C::lane_type(ctx, v2.0);
                                                        let v1971 = constructor_umulhi(ctx, v1816, v30, v27);
                                                        let v1972 = constructor_splat(ctx, v2.0, v1971);
                                                        // Rule at src/opts/vector.isle line 42.
                                                        returns.extend(Some(v1972));
                                                        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 v1816 = C::lane_type(ctx, v2.0);
                                                        let v1969 = constructor_smulhi(ctx, v1816, v30, v27);
                                                        let v1970 = constructor_splat(ctx, v2.0, v1969);
                                                        // Rule at src/opts/vector.isle line 39.
                                                        returns.extend(Some(v1970));
                                                        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 v138,
                                    args: ref v139,
                                } => {
                                    match v138 {
                                        &Opcode::Band => {
                                            if v2.0 == v11.0 {
                                                let v140 = C::unpack_value_array_2(ctx, v139);
                                                if v7.0 == v140.0 {
                                                    let v609 = constructor_band(ctx, v2.0, v7.0, v140.1);
                                                    // Rule at src/opts/bitops.isle line 194.
                                                    returns.extend(Some(v609));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.0 == v140.1 {
                                                    let v610 = constructor_band(ctx, v2.0, v140.0, v7.0);
                                                    // Rule at src/opts/bitops.isle line 195.
                                                    returns.extend(Some(v610));
                                                    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 v102,
                                                        args: ref v103,
                                                    } = &v19.1 {
                                                        if let &Opcode::Band = v102 {
                                                            if v2.0 == v19.0 {
                                                                let v104 = C::unpack_value_array_2(ctx, v103);
                                                                let mut v114 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                                let mut v114 = v114.into_context_iter();
                                                                while let Some(v115) = v114.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v132,
                                                                        imm: v133,
                                                                    } = &v115.1 {
                                                                        if let &Opcode::Iconst = v132 {
                                                                            let mut v414 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v140.1, &mut v414);
                                                                            let mut v414 = v414.into_context_iter();
                                                                            while let Some(v415) = v414.next(ctx) {
                                                                                if let &InstructionData::UnaryImm {
                                                                                    opcode: ref v1097,
                                                                                    imm: v1098,
                                                                                } = &v415.1 {
                                                                                    if let &Opcode::Iconst = v1097 {
                                                                                        let v655 = constructor_band(ctx, v2.0, v104.0, v140.0);
                                                                                        let v1105 = constructor_band(ctx, v2.0, v104.1, v140.1);
                                                                                        let v1106 = constructor_band(ctx, v2.0, v655, v1105);
                                                                                        // Rule at src/opts/cprop.isle line 321.
                                                                                        returns.extend(Some(v1106));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Bor => {
                                            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) {
                                                    match &v19.1 {
                                                        &InstructionData::Binary {
                                                            opcode: ref v102,
                                                            args: ref v103,
                                                        } => {
                                                            if let &Opcode::Bor = v102 {
                                                                if v2.0 == v19.0 {
                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let v140 = C::unpack_value_array_2(ctx, v139);
                                                                    if v104.0 == v140.0 {
                                                                        let mut v114 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                                        let mut v114 = v114.into_context_iter();
                                                                        while let Some(v115) = v114.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v118,
                                                                                arg: v119,
                                                                            } = &v115.1 {
                                                                                if let &Opcode::Bnot = v118 {
                                                                                    if v2.0 == v115.0 {
                                                                                        if v119 == v140.1 {
                                                                                            // Rule at src/opts/bitops.isle line 475.
                                                                                            returns.extend(Some(v104.0));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let mut v414 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v140.1, &mut v414);
                                                                        let mut v414 = v414.into_context_iter();
                                                                        while let Some(v415) = v414.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v613,
                                                                                arg: v614,
                                                                            } = &v415.1 {
                                                                                if let &Opcode::Bnot = v613 {
                                                                                    if v104.1 == v614 {
                                                                                        if v2.0 == v415.0 {
                                                                                            // Rule at src/opts/bitops.isle line 474.
                                                                                            returns.extend(Some(v104.0));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let v667 = constructor_band(ctx, v2.0, v104.1, v140.1);
                                                                        let v668 = constructor_bor(ctx, v2.0, v667, v104.0);
                                                                        // Rule at src/opts/bitops.isle line 261.
                                                                        returns.extend(Some(v668));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        let v669 = constructor_band(ctx, v2.0, v140.1, v104.1);
                                                                        let v670 = constructor_bor(ctx, v2.0, v669, v104.0);
                                                                        // Rule at src/opts/bitops.isle line 262.
                                                                        returns.extend(Some(v670));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        let mut v114 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                                        let mut v114 = v114.into_context_iter();
                                                                        while let Some(v115) = v114.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v118,
                                                                                arg: v119,
                                                                            } = &v115.1 {
                                                                                if let &Opcode::Bnot = v118 {
                                                                                    if v119 == v140.0 {
                                                                                        if v2.0 == v115.0 {
                                                                                            // Rule at src/opts/bitops.isle line 479.
                                                                                            returns.extend(Some(v104.0));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let mut v382 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v140.0, &mut v382);
                                                                        let mut v382 = v382.into_context_iter();
                                                                        while let Some(v383) = v382.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v616,
                                                                                arg: v617,
                                                                            } = &v383.1 {
                                                                                if let &Opcode::Bnot = v616 {
                                                                                    if v104.1 == v617 {
                                                                                        if v2.0 == v383.0 {
                                                                                            // Rule at src/opts/bitops.isle line 476.
                                                                                            returns.extend(Some(v104.0));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let v661 = constructor_band(ctx, v2.0, v140.0, v104.1);
                                                                        let v662 = constructor_bor(ctx, v2.0, v661, v104.0);
                                                                        // Rule at src/opts/bitops.isle line 258.
                                                                        returns.extend(Some(v662));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        let v663 = constructor_band(ctx, v2.0, v104.1, v140.0);
                                                                        let v664 = constructor_bor(ctx, v2.0, v663, v104.0);
                                                                        // Rule at src/opts/bitops.isle line 259.
                                                                        returns.extend(Some(v664));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v104.1 == v140.0 {
                                                                        let mut v107 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v104.0, &mut v107);
                                                                        let mut v107 = v107.into_context_iter();
                                                                        while let Some(v108) = v107.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v111,
                                                                                arg: v112,
                                                                            } = &v108.1 {
                                                                                if let &Opcode::Bnot = v111 {
                                                                                    if v112 == v140.1 {
                                                                                        if v2.0 == v108.0 {
                                                                                            // Rule at src/opts/bitops.isle line 477.
                                                                                            returns.extend(Some(v104.1));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let mut v414 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v140.1, &mut v414);
                                                                        let mut v414 = v414.into_context_iter();
                                                                        while let Some(v415) = v414.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v613,
                                                                                arg: v614,
                                                                            } = &v415.1 {
                                                                                if let &Opcode::Bnot = v613 {
                                                                                    if v104.0 == v614 {
                                                                                        if v2.0 == v415.0 {
                                                                                            // Rule at src/opts/bitops.isle line 478.
                                                                                            returns.extend(Some(v104.1));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let v659 = constructor_band(ctx, v2.0, v104.0, v140.1);
                                                                        let v660 = constructor_bor(ctx, v2.0, v659, v104.1);
                                                                        // Rule at src/opts/bitops.isle line 257.
                                                                        returns.extend(Some(v660));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        let v665 = constructor_band(ctx, v2.0, v140.1, v104.0);
                                                                        let v666 = constructor_bor(ctx, v2.0, v665, v104.1);
                                                                        // Rule at src/opts/bitops.isle line 260.
                                                                        returns.extend(Some(v666));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v104.1 == v140.1 {
                                                                        let mut v107 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v104.0, &mut v107);
                                                                        let mut v107 = v107.into_context_iter();
                                                                        while let Some(v108) = v107.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v111,
                                                                                arg: v112,
                                                                            } = &v108.1 {
                                                                                if let &Opcode::Bnot = v111 {
                                                                                    if v112 == v140.0 {
                                                                                        if v2.0 == v108.0 {
                                                                                            // Rule at src/opts/bitops.isle line 481.
                                                                                            returns.extend(Some(v104.1));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let mut v382 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v140.0, &mut v382);
                                                                        let mut v382 = v382.into_context_iter();
                                                                        while let Some(v383) = v382.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v616,
                                                                                arg: v617,
                                                                            } = &v383.1 {
                                                                                if let &Opcode::Bnot = v616 {
                                                                                    if v104.0 == v617 {
                                                                                        if v2.0 == v383.0 {
                                                                                            // Rule at src/opts/bitops.isle line 480.
                                                                                            returns.extend(Some(v104.1));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let v655 = constructor_band(ctx, v2.0, v104.0, v140.0);
                                                                        let v656 = constructor_bor(ctx, v2.0, v655, v104.1);
                                                                        // Rule at src/opts/bitops.isle line 255.
                                                                        returns.extend(Some(v656));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        let v657 = constructor_band(ctx, v2.0, v140.0, v104.0);
                                                                        let v658 = constructor_bor(ctx, v2.0, v657, v104.1);
                                                                        // Rule at src/opts/bitops.isle line 256.
                                                                        returns.extend(Some(v658));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v29,
                                                            arg: v30,
                                                        } => {
                                                            if let &Opcode::Bnot = v29 {
                                                                if v2.0 == v19.0 {
                                                                    let mut v636 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v30, &mut v636);
                                                                    let mut v636 = v636.into_context_iter();
                                                                    while let Some(v637) = v636.next(ctx) {
                                                                        if let &InstructionData::Binary {
                                                                            opcode: ref v640,
                                                                            args: ref v641,
                                                                        } = &v637.1 {
                                                                            match v640 {
                                                                                &Opcode::Band => {
                                                                                    if v2.0 == v637.0 {
                                                                                        let v140 = C::unpack_value_array_2(ctx, v139);
                                                                                        let mut v382 = C::inst_data_value_etor_returns::default();
                                                                                        C::inst_data_value_etor(ctx, v140.0, &mut v382);
                                                                                        let mut v382 = v382.into_context_iter();
                                                                                        while let Some(v383) = v382.next(ctx) {
                                                                                            if let &InstructionData::Unary {
                                                                                                opcode: ref v616,
                                                                                                arg: v617,
                                                                                            } = &v383.1 {
                                                                                                if let &Opcode::Bnot = v616 {
                                                                                                    if v2.0 == v383.0 {
                                                                                                        let v642 = C::unpack_value_array_2(ctx, v641);
                                                                                                        if v140.1 == v642.0 {
                                                                                                            if v617 == v642.1 {
                                                                                                                let v725 = constructor_bnot(ctx, v2.0, v642.1);
                                                                                                                // Rule at src/opts/bitops.isle line 628.
                                                                                                                returns.extend(Some(v725));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                        if v617 == v642.0 {
                                                                                                            if v140.1 == v642.1 {
                                                                                                                let v721 = constructor_bnot(ctx, v2.0, v642.0);
                                                                                                                // Rule at src/opts/bitops.isle line 626.
                                                                                                                returns.extend(Some(v721));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                        let mut v414 = C::inst_data_value_etor_returns::default();
                                                                                        C::inst_data_value_etor(ctx, v140.1, &mut v414);
                                                                                        let mut v414 = v414.into_context_iter();
                                                                                        while let Some(v415) = v414.next(ctx) {
                                                                                            if let &InstructionData::Unary {
                                                                                                opcode: ref v613,
                                                                                                arg: v614,
                                                                                            } = &v415.1 {
                                                                                                if let &Opcode::Bnot = v613 {
                                                                                                    if v2.0 == v415.0 {
                                                                                                        let v642 = C::unpack_value_array_2(ctx, v641);
                                                                                                        if v140.0 == v642.0 {
                                                                                                            if v614 == v642.1 {
                                                                                                                let v725 = constructor_bnot(ctx, v2.0, v642.1);
                                                                                                                // Rule at src/opts/bitops.isle line 632.
                                                                                                                returns.extend(Some(v725));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                        if v614 == v642.0 {
                                                                                                            if v140.0 == v642.1 {
                                                                                                                let v721 = constructor_bnot(ctx, v2.0, v642.0);
                                                                                                                // Rule at src/opts/bitops.isle line 630.
                                                                                                                returns.extend(Some(v721));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                                &Opcode::Bxor => {
                                                                                    if v2.0 == v637.0 {
                                                                                        let v140 = C::unpack_value_array_2(ctx, v139);
                                                                                        let v642 = C::unpack_value_array_2(ctx, v641);
                                                                                        if v140.0 == v642.0 {
                                                                                            if v140.1 == v642.1 {
                                                                                                let v855 = constructor_band(ctx, v2.0, v642.0, v642.1);
                                                                                                // Rule at src/opts/bitops.isle line 545.
                                                                                                returns.extend(Some(v855));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v856 = constructor_band(ctx, v2.0, v642.1, v642.0);
                                                                                                // Rule at src/opts/bitops.isle line 551.
                                                                                                returns.extend(Some(v856));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                        if v140.0 == v642.1 {
                                                                                            if v140.1 == v642.0 {
                                                                                                let v856 = constructor_band(ctx, v2.0, v642.1, v642.0);
                                                                                                // Rule at src/opts/bitops.isle line 547.
                                                                                                returns.extend(Some(v856));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v855 = constructor_band(ctx, v2.0, v642.0, v642.1);
                                                                                                // Rule at src/opts/bitops.isle line 549.
                                                                                                returns.extend(Some(v855));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                                _ => {}
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let v140 = C::unpack_value_array_2(ctx, v139);
                                                let mut v382 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v140.0, &mut v382);
                                                let mut v382 = v382.into_context_iter();
                                                while let Some(v383) = v382.next(ctx) {
                                                    match &v383.1 {
                                                        &InstructionData::Binary {
                                                            opcode: ref v386,
                                                            args: ref v387,
                                                        } => {
                                                            if let &Opcode::Band = v386 {
                                                                if v2.0 == v383.0 {
                                                                    let v388 = C::unpack_value_array_2(ctx, v387);
                                                                    if v7.0 == v388.0 {
                                                                        let v839 = constructor_bor(ctx, v2.0, v140.1, v388.1);
                                                                        let v840 = constructor_band(ctx, v2.0, v839, v7.0);
                                                                        // Rule at src/opts/bitops.isle line 509.
                                                                        returns.extend(Some(v840));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v7.0 == v388.1 {
                                                                        let v847 = constructor_bor(ctx, v2.0, v140.1, v388.0);
                                                                        let v848 = constructor_band(ctx, v2.0, v847, v7.0);
                                                                        // Rule at src/opts/bitops.isle line 513.
                                                                        returns.extend(Some(v848));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v616,
                                                            arg: v617,
                                                        } => {
                                                            if let &Opcode::Bnot = v616 {
                                                                if v7.0 == v617 {
                                                                    if v2.0 == v383.0 {
                                                                        let v609 = constructor_band(ctx, v2.0, v7.0, v140.1);
                                                                        // Rule at src/opts/bitops.isle line 526.
                                                                        returns.extend(Some(v609));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let mut v414 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v140.1, &mut v414);
                                                let mut v414 = v414.into_context_iter();
                                                while let Some(v415) = v414.next(ctx) {
                                                    match &v415.1 {
                                                        &InstructionData::Binary {
                                                            opcode: ref v418,
                                                            args: ref v419,
                                                        } => {
                                                            if let &Opcode::Band = v418 {
                                                                if v2.0 == v415.0 {
                                                                    let v420 = C::unpack_value_array_2(ctx, v419);
                                                                    if v7.0 == v420.0 {
                                                                        let v835 = constructor_bor(ctx, v2.0, v140.0, v420.1);
                                                                        let v836 = constructor_band(ctx, v2.0, v835, v7.0);
                                                                        // Rule at src/opts/bitops.isle line 507.
                                                                        returns.extend(Some(v836));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v7.0 == v420.1 {
                                                                        let v843 = constructor_bor(ctx, v2.0, v140.0, v420.0);
                                                                        let v844 = constructor_band(ctx, v2.0, v843, v7.0);
                                                                        // Rule at src/opts/bitops.isle line 511.
                                                                        returns.extend(Some(v844));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v613,
                                                            arg: v614,
                                                        } => {
                                                            if let &Opcode::Bnot = v613 {
                                                                if v7.0 == v614 {
                                                                    if v2.0 == v415.0 {
                                                                        let v851 = constructor_band(ctx, v2.0, v7.0, v140.0);
                                                                        // Rule at src/opts/bitops.isle line 528.
                                                                        returns.extend(Some(v851));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                if v7.0 == v140.0 {
                                                    // Rule at src/opts/bitops.isle line 250.
                                                    returns.extend(Some(v7.0));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.0 == v140.1 {
                                                    // Rule at src/opts/bitops.isle line 252.
                                                    returns.extend(Some(v7.0));
                                                    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 v102,
                                                        args: ref v103,
                                                    } = &v19.1 {
                                                        if let &Opcode::Bxor = v102 {
                                                            if v2.0 == v19.0 {
                                                                let v104 = C::unpack_value_array_2(ctx, v103);
                                                                let v140 = C::unpack_value_array_2(ctx, v139);
                                                                if v104.0 == v140.0 {
                                                                    let mut v114 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                                    let mut v114 = v114.into_context_iter();
                                                                    while let Some(v115) = v114.next(ctx) {
                                                                        if let &InstructionData::Binary {
                                                                            opcode: ref v354,
                                                                            args: ref v355,
                                                                        } = &v115.1 {
                                                                            if let &Opcode::Bxor = v354 {
                                                                                if v2.0 == v115.0 {
                                                                                    let v356 = C::unpack_value_array_2(ctx, v355);
                                                                                    if v140.1 == v356.0 {
                                                                                        let v870 = constructor_bxor(ctx, v2.0, v104.0, v356.0);
                                                                                        let v871 = constructor_bnot(ctx, v2.0, v356.1);
                                                                                        let v872 = constructor_band(ctx, v2.0, v870, v871);
                                                                                        // Rule at src/opts/bitops.isle line 591.
                                                                                        returns.extend(Some(v872));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v140.1 == v356.1 {
                                                                                        let v880 = constructor_bxor(ctx, v2.0, v104.0, v356.1);
                                                                                        let v881 = constructor_bnot(ctx, v2.0, v356.0);
                                                                                        let v882 = constructor_band(ctx, v2.0, v880, v881);
                                                                                        // Rule at src/opts/bitops.isle line 595.
                                                                                        returns.extend(Some(v882));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    let mut v414 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v140.1, &mut v414);
                                                                    let mut v414 = v414.into_context_iter();
                                                                    while let Some(v415) = v414.next(ctx) {
                                                                        if let &InstructionData::Binary {
                                                                            opcode: ref v418,
                                                                            args: ref v419,
                                                                        } = &v415.1 {
                                                                            if let &Opcode::Bxor = v418 {
                                                                                if v2.0 == v415.0 {
                                                                                    let v420 = C::unpack_value_array_2(ctx, v419);
                                                                                    if v104.1 == v420.0 {
                                                                                        let v243 = constructor_bxor(ctx, v2.0, v104.0, v104.1);
                                                                                        let v868 = constructor_bnot(ctx, v2.0, v420.1);
                                                                                        let v869 = constructor_band(ctx, v2.0, v243, v868);
                                                                                        // Rule at src/opts/bitops.isle line 590.
                                                                                        returns.extend(Some(v869));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v104.1 == v420.1 {
                                                                                        let v243 = constructor_bxor(ctx, v2.0, v104.0, v104.1);
                                                                                        let v878 = constructor_bnot(ctx, v2.0, v420.0);
                                                                                        let v879 = constructor_band(ctx, v2.0, v243, v878);
                                                                                        // Rule at src/opts/bitops.isle line 594.
                                                                                        returns.extend(Some(v879));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                if v104.0 == v140.1 {
                                                                    let mut v114 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                                    let mut v114 = v114.into_context_iter();
                                                                    while let Some(v115) = v114.next(ctx) {
                                                                        if let &InstructionData::Binary {
                                                                            opcode: ref v354,
                                                                            args: ref v355,
                                                                        } = &v115.1 {
                                                                            if let &Opcode::Bxor = v354 {
                                                                                if v2.0 == v115.0 {
                                                                                    let v356 = C::unpack_value_array_2(ctx, v355);
                                                                                    if v140.0 == v356.0 {
                                                                                        let v870 = constructor_bxor(ctx, v2.0, v104.0, v356.0);
                                                                                        let v871 = constructor_bnot(ctx, v2.0, v356.1);
                                                                                        let v872 = constructor_band(ctx, v2.0, v870, v871);
                                                                                        // Rule at src/opts/bitops.isle line 599.
                                                                                        returns.extend(Some(v872));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v140.0 == v356.1 {
                                                                                        let v880 = constructor_bxor(ctx, v2.0, v104.0, v356.1);
                                                                                        let v881 = constructor_bnot(ctx, v2.0, v356.0);
                                                                                        let v882 = constructor_band(ctx, v2.0, v880, v881);
                                                                                        // Rule at src/opts/bitops.isle line 603.
                                                                                        returns.extend(Some(v882));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    let mut v382 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v140.0, &mut v382);
                                                                    let mut v382 = v382.into_context_iter();
                                                                    while let Some(v383) = v382.next(ctx) {
                                                                        if let &InstructionData::Binary {
                                                                            opcode: ref v386,
                                                                            args: ref v387,
                                                                        } = &v383.1 {
                                                                            if let &Opcode::Bxor = v386 {
                                                                                if v2.0 == v383.0 {
                                                                                    let v388 = C::unpack_value_array_2(ctx, v387);
                                                                                    if v104.1 == v388.0 {
                                                                                        let v243 = constructor_bxor(ctx, v2.0, v104.0, v104.1);
                                                                                        let v863 = constructor_bnot(ctx, v2.0, v388.1);
                                                                                        let v864 = constructor_band(ctx, v2.0, v243, v863);
                                                                                        // Rule at src/opts/bitops.isle line 588.
                                                                                        returns.extend(Some(v864));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v104.1 == v388.1 {
                                                                                        let v243 = constructor_bxor(ctx, v2.0, v104.0, v104.1);
                                                                                        let v873 = constructor_bnot(ctx, v2.0, v388.0);
                                                                                        let v874 = constructor_band(ctx, v2.0, v243, v873);
                                                                                        // Rule at src/opts/bitops.isle line 592.
                                                                                        returns.extend(Some(v874));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                if v104.1 == v140.0 {
                                                                    let mut v107 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v104.0, &mut v107);
                                                                    let mut v107 = v107.into_context_iter();
                                                                    while let Some(v108) = v107.next(ctx) {
                                                                        if let &InstructionData::Binary {
                                                                            opcode: ref v342,
                                                                            args: ref v343,
                                                                        } = &v108.1 {
                                                                            if let &Opcode::Bxor = v342 {
                                                                                if v2.0 == v108.0 {
                                                                                    let v344 = C::unpack_value_array_2(ctx, v343);
                                                                                    if v140.1 == v344.0 {
                                                                                        let v865 = constructor_bxor(ctx, v2.0, v104.1, v344.0);
                                                                                        let v866 = constructor_bnot(ctx, v2.0, v344.1);
                                                                                        let v867 = constructor_band(ctx, v2.0, v865, v866);
                                                                                        // Rule at src/opts/bitops.isle line 589.
                                                                                        returns.extend(Some(v867));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v140.1 == v344.1 {
                                                                                        let v875 = constructor_bxor(ctx, v2.0, v104.1, v344.1);
                                                                                        let v876 = constructor_bnot(ctx, v2.0, v344.0);
                                                                                        let v877 = constructor_band(ctx, v2.0, v875, v876);
                                                                                        // Rule at src/opts/bitops.isle line 593.
                                                                                        returns.extend(Some(v877));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    let mut v414 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v140.1, &mut v414);
                                                                    let mut v414 = v414.into_context_iter();
                                                                    while let Some(v415) = v414.next(ctx) {
                                                                        if let &InstructionData::Binary {
                                                                            opcode: ref v418,
                                                                            args: ref v419,
                                                                        } = &v415.1 {
                                                                            if let &Opcode::Bxor = v418 {
                                                                                if v2.0 == v415.0 {
                                                                                    let v420 = C::unpack_value_array_2(ctx, v419);
                                                                                    if v104.0 == v420.0 {
                                                                                        let v244 = constructor_bxor(ctx, v2.0, v104.1, v104.0);
                                                                                        let v868 = constructor_bnot(ctx, v2.0, v420.1);
                                                                                        let v884 = constructor_band(ctx, v2.0, v244, v868);
                                                                                        // Rule at src/opts/bitops.isle line 598.
                                                                                        returns.extend(Some(v884));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v104.0 == v420.1 {
                                                                                        let v244 = constructor_bxor(ctx, v2.0, v104.1, v104.0);
                                                                                        let v878 = constructor_bnot(ctx, v2.0, v420.0);
                                                                                        let v886 = constructor_band(ctx, v2.0, v244, v878);
                                                                                        // Rule at src/opts/bitops.isle line 602.
                                                                                        returns.extend(Some(v886));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                if v104.1 == v140.1 {
                                                                    let mut v107 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v104.0, &mut v107);
                                                                    let mut v107 = v107.into_context_iter();
                                                                    while let Some(v108) = v107.next(ctx) {
                                                                        if let &InstructionData::Binary {
                                                                            opcode: ref v342,
                                                                            args: ref v343,
                                                                        } = &v108.1 {
                                                                            if let &Opcode::Bxor = v342 {
                                                                                if v2.0 == v108.0 {
                                                                                    let v344 = C::unpack_value_array_2(ctx, v343);
                                                                                    if v140.0 == v344.0 {
                                                                                        let v865 = constructor_bxor(ctx, v2.0, v104.1, v344.0);
                                                                                        let v866 = constructor_bnot(ctx, v2.0, v344.1);
                                                                                        let v867 = constructor_band(ctx, v2.0, v865, v866);
                                                                                        // Rule at src/opts/bitops.isle line 597.
                                                                                        returns.extend(Some(v867));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v140.0 == v344.1 {
                                                                                        let v875 = constructor_bxor(ctx, v2.0, v104.1, v344.1);
                                                                                        let v876 = constructor_bnot(ctx, v2.0, v344.0);
                                                                                        let v877 = constructor_band(ctx, v2.0, v875, v876);
                                                                                        // Rule at src/opts/bitops.isle line 601.
                                                                                        returns.extend(Some(v877));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    let mut v382 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v140.0, &mut v382);
                                                                    let mut v382 = v382.into_context_iter();
                                                                    while let Some(v383) = v382.next(ctx) {
                                                                        if let &InstructionData::Binary {
                                                                            opcode: ref v386,
                                                                            args: ref v387,
                                                                        } = &v383.1 {
                                                                            if let &Opcode::Bxor = v386 {
                                                                                if v2.0 == v383.0 {
                                                                                    let v388 = C::unpack_value_array_2(ctx, v387);
                                                                                    if v104.0 == v388.0 {
                                                                                        let v244 = constructor_bxor(ctx, v2.0, v104.1, v104.0);
                                                                                        let v863 = constructor_bnot(ctx, v2.0, v388.1);
                                                                                        let v883 = constructor_band(ctx, v2.0, v244, v863);
                                                                                        // Rule at src/opts/bitops.isle line 596.
                                                                                        returns.extend(Some(v883));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v104.0 == v388.1 {
                                                                                        let v244 = constructor_bxor(ctx, v2.0, v104.1, v104.0);
                                                                                        let v873 = constructor_bnot(ctx, v2.0, v388.0);
                                                                                        let v885 = constructor_band(ctx, v2.0, v244, v873);
                                                                                        // Rule at src/opts/bitops.isle line 600.
                                                                                        returns.extend(Some(v885));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                let v140 = C::unpack_value_array_2(ctx, v139);
                                                let mut v382 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v140.0, &mut v382);
                                                let mut v382 = v382.into_context_iter();
                                                while let Some(v383) = v382.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v616,
                                                        arg: v617,
                                                    } = &v383.1 {
                                                        if let &Opcode::Bnot = v616 {
                                                            if v2.0 == v383.0 {
                                                                if v7.0 == v617 {
                                                                    let v609 = constructor_band(ctx, v2.0, v7.0, v140.1);
                                                                    // Rule at src/opts/bitops.isle line 572.
                                                                    returns.extend(Some(v609));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v7.0 == v140.1 {
                                                                    let v618 = constructor_band(ctx, v2.0, v7.0, v617);
                                                                    // Rule at src/opts/bitops.isle line 201.
                                                                    returns.extend(Some(v618));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                let mut v414 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v140.1, &mut v414);
                                                let mut v414 = v414.into_context_iter();
                                                while let Some(v415) = v414.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v613,
                                                        arg: v614,
                                                    } = &v415.1 {
                                                        if let &Opcode::Bnot = v613 {
                                                            if v2.0 == v415.0 {
                                                                if v7.0 == v140.0 {
                                                                    let v615 = constructor_band(ctx, v2.0, v7.0, v614);
                                                                    // Rule at src/opts/bitops.isle line 200.
                                                                    returns.extend(Some(v615));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v7.0 == v614 {
                                                                    let v851 = constructor_band(ctx, v2.0, v7.0, v140.0);
                                                                    // Rule at src/opts/bitops.isle line 574.
                                                                    returns.extend(Some(v851));
                                                                    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 v102,
                                                        args: ref v103,
                                                    } = &v19.1 {
                                                        if let &Opcode::Ishl = v102 {
                                                            if v2.0 == v19.0 {
                                                                let v104 = C::unpack_value_array_2(ctx, v103);
                                                                let v140 = C::unpack_value_array_2(ctx, v139);
                                                                if v104.1 == v140.1 {
                                                                    let v655 = constructor_band(ctx, v2.0, v104.0, v140.0);
                                                                    let v1871 = constructor_ishl(ctx, v2.0, v655, v104.1);
                                                                    // Rule at src/opts/shifts.isle line 312.
                                                                    returns.extend(Some(v1871));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::IntCompare {
                                    opcode: ref v742,
                                    args: ref v743,
                                    cond: ref v744,
                                } => {
                                    if let &Opcode::Icmp = v742 {
                                        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 v736,
                                                args: ref v737,
                                                cond: ref v738,
                                            } = &v19.1 {
                                                if let &Opcode::Icmp = v736 {
                                                    if v11.0 == v19.0 {
                                                        match v738 {
                                                            &IntCC::NotEqual => {
                                                                match v744 {
                                                                    &IntCC::UnsignedGreaterThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v739 = C::unpack_value_array_2(ctx, v737);
                                                                            let v745 = C::unpack_value_array_2(ctx, v743);
                                                                            if v739.0 == v745.1 {
                                                                                let mut v1519 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v739.1, &mut v1519);
                                                                                let mut v1519 = v1519.into_context_iter();
                                                                                while let Some(v1520) = v1519.next(ctx) {
                                                                                    let v1521 = C::iconst_sextend_etor(ctx, v1520);
                                                                                    if let Some(v1522) = v1521 {
                                                                                        if v1522.1 == -1_i64 {
                                                                                            let v1547 = constructor_ult(ctx, v2.0, v739.0, v745.0);
                                                                                            // Rule at src/opts/icmp.isle line 358.
                                                                                            returns.extend(Some(v1547));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            if v739.1 == v745.1 {
                                                                                let mut v1532 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v739.0, &mut v1532);
                                                                                let mut v1532 = v1532.into_context_iter();
                                                                                while let Some(v1533) = v1532.next(ctx) {
                                                                                    let v1534 = C::iconst_sextend_etor(ctx, v1533);
                                                                                    if let Some(v1535) = v1534 {
                                                                                        if v1535.1 == -1_i64 {
                                                                                            let v1549 = constructor_ult(ctx, v2.0, v739.1, v745.0);
                                                                                            // Rule at src/opts/icmp.isle line 364.
                                                                                            returns.extend(Some(v1549));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v739 = C::unpack_value_array_2(ctx, v737);
                                                                            let v745 = C::unpack_value_array_2(ctx, v743);
                                                                            if v739.0 == v745.0 {
                                                                                let mut v1519 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v739.1, &mut v1519);
                                                                                let mut v1519 = v1519.into_context_iter();
                                                                                while let Some(v1520) = v1519.next(ctx) {
                                                                                    let v1521 = C::iconst_sextend_etor(ctx, v1520);
                                                                                    if let Some(v1522) = v1521 {
                                                                                        if v1522.1 == -1_i64 {
                                                                                            let v1548 = constructor_ult(ctx, v2.0, v739.0, v745.1);
                                                                                            // Rule at src/opts/icmp.isle line 361.
                                                                                            returns.extend(Some(v1548));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            if v739.1 == v745.0 {
                                                                                let mut v1532 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v739.0, &mut v1532);
                                                                                let mut v1532 = v1532.into_context_iter();
                                                                                while let Some(v1533) = v1532.next(ctx) {
                                                                                    let v1534 = C::iconst_sextend_etor(ctx, v1533);
                                                                                    if let Some(v1535) = v1534 {
                                                                                        if v1535.1 == -1_i64 {
                                                                                            let v1550 = constructor_ult(ctx, v2.0, v739.1, v745.1);
                                                                                            // Rule at src/opts/icmp.isle line 367.
                                                                                            returns.extend(Some(v1550));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                            &IntCC::SignedGreaterThan => {
                                                                match v744 {
                                                                    &IntCC::SignedLessThan => {
                                                                        let v301 = C::ty_int_vec128(ctx, v2.0);
                                                                        if let Some(v302) = v301 {
                                                                            if v11.0 == v302 {
                                                                                let v739 = C::unpack_value_array_2(ctx, v737);
                                                                                let v745 = C::unpack_value_array_2(ctx, v743);
                                                                                if v739.0 == v745.0 {
                                                                                    if v739.1 == v745.1 {
                                                                                        let v305 = constructor_iconst_u(ctx, v302, 0x0_u64);
                                                                                        // Rule at src/opts/icmp.isle line 319.
                                                                                        returns.extend(Some(v305));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v739 = C::unpack_value_array_2(ctx, v737);
                                                                            let v745 = C::unpack_value_array_2(ctx, v743);
                                                                            if v739.0 == v745.0 {
                                                                                let mut v1519 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v739.1, &mut v1519);
                                                                                let mut v1519 = v1519.into_context_iter();
                                                                                while let Some(v1520) = v1519.next(ctx) {
                                                                                    let v1521 = C::iconst_sextend_etor(ctx, v1520);
                                                                                    if let Some(v1522) = v1521 {
                                                                                        let v1531 = C::i64_gt_eq(ctx, v1522.1, 0_i64);
                                                                                        if v1531 == true {
                                                                                            let mut v1525 = C::inst_data_value_tupled_etor_returns::default();
                                                                                            C::inst_data_value_tupled_etor(ctx, v745.1, &mut v1525);
                                                                                            let mut v1525 = v1525.into_context_iter();
                                                                                            while let Some(v1526) = v1525.next(ctx) {
                                                                                                let v1527 = C::iconst_sextend_etor(ctx, v1526);
                                                                                                if let Some(v1528) = v1527 {
                                                                                                    if v1522.1 == v1528.1 {
                                                                                                        let v53 = constructor_iconst_u(ctx, v2.0, 0x0_u64);
                                                                                                        // Rule at src/opts/icmp.isle line 324.
                                                                                                        returns.extend(Some(v53));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            if v739.1 == v745.1 {
                                                                                let mut v1532 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v739.0, &mut v1532);
                                                                                let mut v1532 = v1532.into_context_iter();
                                                                                while let Some(v1533) = v1532.next(ctx) {
                                                                                    let v1534 = C::iconst_sextend_etor(ctx, v1533);
                                                                                    if let Some(v1535) = v1534 {
                                                                                        let v1544 = C::i64_lt(ctx, v1535.1, 0_i64);
                                                                                        if v1544 == true {
                                                                                            let mut v1538 = C::inst_data_value_tupled_etor_returns::default();
                                                                                            C::inst_data_value_tupled_etor(ctx, v745.0, &mut v1538);
                                                                                            let mut v1538 = v1538.into_context_iter();
                                                                                            while let Some(v1539) = v1538.next(ctx) {
                                                                                                let v1540 = C::iconst_sextend_etor(ctx, v1539);
                                                                                                if let Some(v1541) = v1540 {
                                                                                                    if v1535.1 == v1541.1 {
                                                                                                        let v53 = constructor_iconst_u(ctx, v2.0, 0x0_u64);
                                                                                                        // Rule at src/opts/icmp.isle line 328.
                                                                                                        returns.extend(Some(v53));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                            &IntCC::SignedLessThan => {
                                                                match v744 {
                                                                    &IntCC::SignedGreaterThan => {
                                                                        let v301 = C::ty_int_vec128(ctx, v2.0);
                                                                        if let Some(v302) = v301 {
                                                                            if v11.0 == v302 {
                                                                                let v739 = C::unpack_value_array_2(ctx, v737);
                                                                                let v745 = C::unpack_value_array_2(ctx, v743);
                                                                                if v739.0 == v745.0 {
                                                                                    if v739.1 == v745.1 {
                                                                                        let v305 = constructor_iconst_u(ctx, v302, 0x0_u64);
                                                                                        // Rule at src/opts/icmp.isle line 320.
                                                                                        returns.extend(Some(v305));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedGreaterThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v739 = C::unpack_value_array_2(ctx, v737);
                                                                            let v745 = C::unpack_value_array_2(ctx, v743);
                                                                            if v739.0 == v745.0 {
                                                                                let mut v1519 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v739.1, &mut v1519);
                                                                                let mut v1519 = v1519.into_context_iter();
                                                                                while let Some(v1520) = v1519.next(ctx) {
                                                                                    let v1521 = C::iconst_sextend_etor(ctx, v1520);
                                                                                    if let Some(v1522) = v1521 {
                                                                                        let v1545 = C::i64_lt(ctx, v1522.1, 0_i64);
                                                                                        if v1545 == true {
                                                                                            let mut v1525 = C::inst_data_value_tupled_etor_returns::default();
                                                                                            C::inst_data_value_tupled_etor(ctx, v745.1, &mut v1525);
                                                                                            let mut v1525 = v1525.into_context_iter();
                                                                                            while let Some(v1526) = v1525.next(ctx) {
                                                                                                let v1527 = C::iconst_sextend_etor(ctx, v1526);
                                                                                                if let Some(v1528) = v1527 {
                                                                                                    if v1522.1 == v1528.1 {
                                                                                                        let v53 = constructor_iconst_u(ctx, v2.0, 0x0_u64);
                                                                                                        // Rule at src/opts/icmp.isle line 332.
                                                                                                        returns.extend(Some(v53));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            if v739.1 == v745.1 {
                                                                                let mut v1532 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v739.0, &mut v1532);
                                                                                let mut v1532 = v1532.into_context_iter();
                                                                                while let Some(v1533) = v1532.next(ctx) {
                                                                                    let v1534 = C::iconst_sextend_etor(ctx, v1533);
                                                                                    if let Some(v1535) = v1534 {
                                                                                        let v1546 = C::i64_gt_eq(ctx, v1535.1, 0_i64);
                                                                                        if v1546 == true {
                                                                                            let mut v1538 = C::inst_data_value_tupled_etor_returns::default();
                                                                                            C::inst_data_value_tupled_etor(ctx, v745.0, &mut v1538);
                                                                                            let mut v1538 = v1538.into_context_iter();
                                                                                            while let Some(v1539) = v1538.next(ctx) {
                                                                                                let v1540 = C::iconst_sextend_etor(ctx, v1539);
                                                                                                if let Some(v1541) = v1540 {
                                                                                                    if v1535.1 == v1541.1 {
                                                                                                        let v53 = constructor_iconst_u(ctx, v2.0, 0x0_u64);
                                                                                                        // Rule at src/opts/icmp.isle line 336.
                                                                                                        returns.extend(Some(v53));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                            &IntCC::UnsignedGreaterThan => {
                                                                match v744 {
                                                                    &IntCC::NotEqual => {
                                                                        if v2.0 == v11.0 {
                                                                            let v739 = C::unpack_value_array_2(ctx, v737);
                                                                            let v745 = C::unpack_value_array_2(ctx, v743);
                                                                            if v739.1 == v745.0 {
                                                                                let mut v1525 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v745.1, &mut v1525);
                                                                                let mut v1525 = v1525.into_context_iter();
                                                                                while let Some(v1526) = v1525.next(ctx) {
                                                                                    let v1527 = C::iconst_sextend_etor(ctx, v1526);
                                                                                    if let Some(v1528) = v1527 {
                                                                                        if v1528.1 == -1_i64 {
                                                                                            let v1551 = constructor_ult(ctx, v2.0, v739.1, v739.0);
                                                                                            // Rule at src/opts/icmp.isle line 370.
                                                                                            returns.extend(Some(v1551));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            if v739.1 == v745.1 {
                                                                                let mut v1538 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v745.0, &mut v1538);
                                                                                let mut v1538 = v1538.into_context_iter();
                                                                                while let Some(v1539) = v1538.next(ctx) {
                                                                                    let v1540 = C::iconst_sextend_etor(ctx, v1539);
                                                                                    if let Some(v1541) = v1540 {
                                                                                        if v1541.1 == -1_i64 {
                                                                                            let v1551 = constructor_ult(ctx, v2.0, v739.1, v739.0);
                                                                                            // Rule at src/opts/icmp.isle line 373.
                                                                                            returns.extend(Some(v1551));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedLessThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v739 = C::unpack_value_array_2(ctx, v737);
                                                                            let v745 = C::unpack_value_array_2(ctx, v743);
                                                                            if v739.0 == v745.0 {
                                                                                let mut v1519 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v739.1, &mut v1519);
                                                                                let mut v1519 = v1519.into_context_iter();
                                                                                while let Some(v1520) = v1519.next(ctx) {
                                                                                    let v1521 = C::iconst_sextend_etor(ctx, v1520);
                                                                                    if let Some(v1522) = v1521 {
                                                                                        let v1545 = C::i64_lt(ctx, v1522.1, 0_i64);
                                                                                        if v1545 == true {
                                                                                            let mut v1525 = C::inst_data_value_tupled_etor_returns::default();
                                                                                            C::inst_data_value_tupled_etor(ctx, v745.1, &mut v1525);
                                                                                            let mut v1525 = v1525.into_context_iter();
                                                                                            while let Some(v1526) = v1525.next(ctx) {
                                                                                                let v1527 = C::iconst_sextend_etor(ctx, v1526);
                                                                                                if let Some(v1528) = v1527 {
                                                                                                    if v1522.1 == v1528.1 {
                                                                                                        let v53 = constructor_iconst_u(ctx, v2.0, 0x0_u64);
                                                                                                        // Rule at src/opts/icmp.isle line 340.
                                                                                                        returns.extend(Some(v53));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            if v739.1 == v745.1 {
                                                                                let mut v1532 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v739.0, &mut v1532);
                                                                                let mut v1532 = v1532.into_context_iter();
                                                                                while let Some(v1533) = v1532.next(ctx) {
                                                                                    let v1534 = C::iconst_sextend_etor(ctx, v1533);
                                                                                    if let Some(v1535) = v1534 {
                                                                                        let v1546 = C::i64_gt_eq(ctx, v1535.1, 0_i64);
                                                                                        if v1546 == true {
                                                                                            let mut v1538 = C::inst_data_value_tupled_etor_returns::default();
                                                                                            C::inst_data_value_tupled_etor(ctx, v745.0, &mut v1538);
                                                                                            let mut v1538 = v1538.into_context_iter();
                                                                                            while let Some(v1539) = v1538.next(ctx) {
                                                                                                let v1540 = C::iconst_sextend_etor(ctx, v1539);
                                                                                                if let Some(v1541) = v1540 {
                                                                                                    if v1535.1 == v1541.1 {
                                                                                                        let v53 = constructor_iconst_u(ctx, v2.0, 0x0_u64);
                                                                                                        // Rule at src/opts/icmp.isle line 344.
                                                                                                        returns.extend(Some(v53));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        let v301 = C::ty_int_vec128(ctx, v2.0);
                                                                        if let Some(v302) = v301 {
                                                                            if v11.0 == v302 {
                                                                                let v739 = C::unpack_value_array_2(ctx, v737);
                                                                                let v745 = C::unpack_value_array_2(ctx, v743);
                                                                                if v739.0 == v745.0 {
                                                                                    if v739.1 == v745.1 {
                                                                                        let v305 = constructor_iconst_u(ctx, v302, 0x0_u64);
                                                                                        // Rule at src/opts/icmp.isle line 321.
                                                                                        returns.extend(Some(v305));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                            &IntCC::UnsignedLessThan => {
                                                                match v744 {
                                                                    &IntCC::NotEqual => {
                                                                        if v2.0 == v11.0 {
                                                                            let v739 = C::unpack_value_array_2(ctx, v737);
                                                                            let v745 = C::unpack_value_array_2(ctx, v743);
                                                                            if v739.0 == v745.0 {
                                                                                let mut v1525 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v745.1, &mut v1525);
                                                                                let mut v1525 = v1525.into_context_iter();
                                                                                while let Some(v1526) = v1525.next(ctx) {
                                                                                    let v1527 = C::iconst_sextend_etor(ctx, v1526);
                                                                                    if let Some(v1528) = v1527 {
                                                                                        if v1528.1 == -1_i64 {
                                                                                            let v1552 = constructor_ult(ctx, v2.0, v739.0, v739.1);
                                                                                            // Rule at src/opts/icmp.isle line 376.
                                                                                            returns.extend(Some(v1552));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            if v739.0 == v745.1 {
                                                                                let mut v1538 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v745.0, &mut v1538);
                                                                                let mut v1538 = v1538.into_context_iter();
                                                                                while let Some(v1539) = v1538.next(ctx) {
                                                                                    let v1540 = C::iconst_sextend_etor(ctx, v1539);
                                                                                    if let Some(v1541) = v1540 {
                                                                                        if v1541.1 == -1_i64 {
                                                                                            let v1552 = constructor_ult(ctx, v2.0, v739.0, v739.1);
                                                                                            // Rule at src/opts/icmp.isle line 379.
                                                                                            returns.extend(Some(v1552));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedGreaterThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v739 = C::unpack_value_array_2(ctx, v737);
                                                                            let v745 = C::unpack_value_array_2(ctx, v743);
                                                                            if v739.0 == v745.0 {
                                                                                let mut v1519 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v739.1, &mut v1519);
                                                                                let mut v1519 = v1519.into_context_iter();
                                                                                while let Some(v1520) = v1519.next(ctx) {
                                                                                    let v1521 = C::iconst_sextend_etor(ctx, v1520);
                                                                                    if let Some(v1522) = v1521 {
                                                                                        let v1531 = C::i64_gt_eq(ctx, v1522.1, 0_i64);
                                                                                        if v1531 == true {
                                                                                            let mut v1525 = C::inst_data_value_tupled_etor_returns::default();
                                                                                            C::inst_data_value_tupled_etor(ctx, v745.1, &mut v1525);
                                                                                            let mut v1525 = v1525.into_context_iter();
                                                                                            while let Some(v1526) = v1525.next(ctx) {
                                                                                                let v1527 = C::iconst_sextend_etor(ctx, v1526);
                                                                                                if let Some(v1528) = v1527 {
                                                                                                    if v1522.1 == v1528.1 {
                                                                                                        let v53 = constructor_iconst_u(ctx, v2.0, 0x0_u64);
                                                                                                        // Rule at src/opts/icmp.isle line 348.
                                                                                                        returns.extend(Some(v53));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            if v739.1 == v745.1 {
                                                                                let mut v1532 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v739.0, &mut v1532);
                                                                                let mut v1532 = v1532.into_context_iter();
                                                                                while let Some(v1533) = v1532.next(ctx) {
                                                                                    let v1534 = C::iconst_sextend_etor(ctx, v1533);
                                                                                    if let Some(v1535) = v1534 {
                                                                                        let v1544 = C::i64_lt(ctx, v1535.1, 0_i64);
                                                                                        if v1544 == true {
                                                                                            let mut v1538 = C::inst_data_value_tupled_etor_returns::default();
                                                                                            C::inst_data_value_tupled_etor(ctx, v745.0, &mut v1538);
                                                                                            let mut v1538 = v1538.into_context_iter();
                                                                                            while let Some(v1539) = v1538.next(ctx) {
                                                                                                let v1540 = C::iconst_sextend_etor(ctx, v1539);
                                                                                                if let Some(v1541) = v1540 {
                                                                                                    if v1535.1 == v1541.1 {
                                                                                                        let v53 = constructor_iconst_u(ctx, v2.0, 0x0_u64);
                                                                                                        // Rule at src/opts/icmp.isle line 352.
                                                                                                        returns.extend(Some(v53));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedGreaterThan => {
                                                                        let v301 = C::ty_int_vec128(ctx, v2.0);
                                                                        if let Some(v302) = v301 {
                                                                            if v11.0 == v302 {
                                                                                let v739 = C::unpack_value_array_2(ctx, v737);
                                                                                let v745 = C::unpack_value_array_2(ctx, v743);
                                                                                if v739.0 == v745.0 {
                                                                                    if v739.1 == v745.1 {
                                                                                        let v305 = constructor_iconst_u(ctx, v302, 0x0_u64);
                                                                                        // Rule at src/opts/icmp.isle line 322.
                                                                                        returns.extend(Some(v305));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                        let v292 = C::fits_in_64(ctx, v2.0);
                                                        if let Some(v293) = v292 {
                                                            if v11.0 == v293 {
                                                                let v1439 = constructor_intcc_comparable(ctx, v738, v744);
                                                                if let Some(v1440) = v1439 {
                                                                    let v739 = C::unpack_value_array_2(ctx, v737);
                                                                    let v745 = C::unpack_value_array_2(ctx, v743);
                                                                    if v739.0 == v745.0 {
                                                                        if v739.1 == v745.1 {
                                                                            let v1441 = constructor_decompose_intcc(ctx, v738);
                                                                            let v1442 = constructor_decompose_intcc(ctx, v744);
                                                                            let v1443 = C::u64_and(ctx, v1441, v1442);
                                                                            let v1444 = constructor_compose_icmp(ctx, v293, v1443, v1440, v739.0, v739.1);
                                                                            // Rule at src/opts/icmp.isle line 179.
                                                                            returns.extend(Some(v1444));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v26,
                                    arg: v27,
                                } => {
                                    match v26 {
                                        &Opcode::Splat => {
                                            let v1953 = C::ty_vector_not_float(ctx, v2.0);
                                            if let Some(v1954) = v1953 {
                                                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 v1816 = C::lane_type(ctx, v2.0);
                                                                    let v1955 = constructor_band(ctx, v1816, v30, v27);
                                                                    let v1956 = constructor_splat(ctx, v2.0, v1955);
                                                                    // Rule at src/opts/vector.isle line 14.
                                                                    returns.extend(Some(v1956));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Bnot => {
                                            if v2.0 == v11.0 {
                                                let mut v626 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v27, &mut v626);
                                                let mut v626 = v626.into_context_iter();
                                                while let Some(v627) = v626.next(ctx) {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v630,
                                                        args: ref v631,
                                                    } = &v627.1 {
                                                        match v630 {
                                                            &Opcode::Band => {
                                                                if v2.0 == v627.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 v102,
                                                                            args: ref v103,
                                                                        } = &v19.1 {
                                                                            if let &Opcode::Bor = v102 {
                                                                                if v2.0 == v19.0 {
                                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                                    let mut v107 = C::inst_data_value_etor_returns::default();
                                                                                    C::inst_data_value_etor(ctx, v104.0, &mut v107);
                                                                                    let mut v107 = v107.into_context_iter();
                                                                                    while let Some(v108) = v107.next(ctx) {
                                                                                        if let &InstructionData::Unary {
                                                                                            opcode: ref v111,
                                                                                            arg: v112,
                                                                                        } = &v108.1 {
                                                                                            if let &Opcode::Bnot = v111 {
                                                                                                if v2.0 == v108.0 {
                                                                                                    let v632 = C::unpack_value_array_2(ctx, v631);
                                                                                                    if v104.1 == v632.0 {
                                                                                                        if v112 == v632.1 {
                                                                                                            let v898 = constructor_bnot(ctx, v2.0, v112);
                                                                                                            // Rule at src/opts/bitops.isle line 627.
                                                                                                            returns.extend(Some(v898));
                                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                        }
                                                                                                    }
                                                                                                    if v112 == v632.0 {
                                                                                                        if v104.1 == v632.1 {
                                                                                                            let v898 = constructor_bnot(ctx, v2.0, v112);
                                                                                                            // Rule at src/opts/bitops.isle line 625.
                                                                                                            returns.extend(Some(v898));
                                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                    let mut v114 = C::inst_data_value_etor_returns::default();
                                                                                    C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                                                    let mut v114 = v114.into_context_iter();
                                                                                    while let Some(v115) = v114.next(ctx) {
                                                                                        if let &InstructionData::Unary {
                                                                                            opcode: ref v118,
                                                                                            arg: v119,
                                                                                        } = &v115.1 {
                                                                                            if let &Opcode::Bnot = v118 {
                                                                                                if v2.0 == v115.0 {
                                                                                                    let v632 = C::unpack_value_array_2(ctx, v631);
                                                                                                    if v104.0 == v632.0 {
                                                                                                        if v119 == v632.1 {
                                                                                                            let v899 = constructor_bnot(ctx, v2.0, v119);
                                                                                                            // Rule at src/opts/bitops.isle line 631.
                                                                                                            returns.extend(Some(v899));
                                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                        }
                                                                                                    }
                                                                                                    if v119 == v632.0 {
                                                                                                        if v104.0 == v632.1 {
                                                                                                            let v899 = constructor_bnot(ctx, v2.0, v119);
                                                                                                            // Rule at src/opts/bitops.isle line 629.
                                                                                                            returns.extend(Some(v899));
                                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    let v632 = C::unpack_value_array_2(ctx, v631);
                                                                    if v7.0 == v632.0 {
                                                                        let v723 = constructor_bnot(ctx, v2.0, v632.1);
                                                                        let v729 = constructor_band(ctx, v2.0, v7.0, v723);
                                                                        // Rule at src/opts/bitops.isle line 321.
                                                                        returns.extend(Some(v729));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v7.0 == v632.1 {
                                                                        let v719 = constructor_bnot(ctx, v2.0, v632.0);
                                                                        let v727 = constructor_band(ctx, v2.0, v7.0, v719);
                                                                        // Rule at src/opts/bitops.isle line 319.
                                                                        returns.extend(Some(v727));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Bxor => {
                                                                if v2.0 == v627.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 v102,
                                                                            args: ref v103,
                                                                        } = &v19.1 {
                                                                            if let &Opcode::Bor = v102 {
                                                                                if v2.0 == v19.0 {
                                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                                    let v632 = C::unpack_value_array_2(ctx, v631);
                                                                                    if v104.0 == v632.0 {
                                                                                        if v104.1 == v632.1 {
                                                                                            let v143 = constructor_band(ctx, v2.0, v104.0, v104.1);
                                                                                            // Rule at src/opts/bitops.isle line 544.
                                                                                            returns.extend(Some(v143));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            let v247 = constructor_band(ctx, v2.0, v104.1, v104.0);
                                                                                            // Rule at src/opts/bitops.isle line 550.
                                                                                            returns.extend(Some(v247));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                    if v104.0 == v632.1 {
                                                                                        if v104.1 == v632.0 {
                                                                                            let v143 = constructor_band(ctx, v2.0, v104.0, v104.1);
                                                                                            // Rule at src/opts/bitops.isle line 546.
                                                                                            returns.extend(Some(v143));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            let v247 = constructor_band(ctx, v2.0, v104.1, v104.0);
                                                                                            // Rule at src/opts/bitops.isle line 548.
                                                                                            returns.extend(Some(v247));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    let v632 = C::unpack_value_array_2(ctx, v631);
                                                                    if v7.0 == v632.0 {
                                                                        let v861 = constructor_band(ctx, v2.0, v7.0, v632.1);
                                                                        // Rule at src/opts/bitops.isle line 566.
                                                                        returns.extend(Some(v861));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v7.0 == v632.1 {
                                                                        let v862 = constructor_band(ctx, v2.0, v7.0, v632.0);
                                                                        // Rule at src/opts/bitops.isle line 568.
                                                                        returns.extend(Some(v862));
                                                                        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::Bnot = v29 {
                                                            if v2.0 == v19.0 {
                                                                let v687 = constructor_bor(ctx, v2.0, v30, v27);
                                                                let v688 = constructor_bnot(ctx, v2.0, v687);
                                                                // Rule at src/opts/bitops.isle line 285.
                                                                returns.extend(Some(v688));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                let v689 = constructor_bor(ctx, v2.0, v27, v30);
                                                                let v690 = constructor_bnot(ctx, v2.0, v689);
                                                                // Rule at src/opts/bitops.isle line 286.
                                                                returns.extend(Some(v690));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            let v301 = C::ty_int_vec128(ctx, v2.0);
                                            if let Some(v302) = v301 {
                                                if v11.0 == v302 {
                                                    if v7.0 == v27 {
                                                        let v305 = constructor_iconst_u(ctx, v302, 0x0_u64);
                                                        let v306 = C::subsume(ctx, v305);
                                                        // Rule at src/opts/bitops.isle line 34.
                                                        returns.extend(Some(v306));
                                                        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 v1316 = C::value_type(ctx, v30);
                                                        let v1347 = C::value_type(ctx, v27);
                                                        if v1316 == v1347 {
                                                            let v1348 = constructor_band(ctx, v1316, v30, v27);
                                                            let v1349 = constructor_uextend(ctx, v2.0, v1348);
                                                            // Rule at src/opts/extends.isle line 70.
                                                            returns.extend(Some(v1349));
                                                            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 v102,
                                                    args: ref v103,
                                                } => {
                                                    if let &Opcode::Band = v102 {
                                                        if v2.0 == v11.0 {
                                                            if v2.0 == v19.0 {
                                                                let v104 = C::unpack_value_array_2(ctx, v103);
                                                                let mut v114 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                                let mut v114 = v114.into_context_iter();
                                                                while let Some(v115) = v114.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v132,
                                                                        imm: v133,
                                                                    } = &v115.1 {
                                                                        if let &Opcode::Iconst = v132 {
                                                                            if v2.0 == v115.0 {
                                                                                let v1026 = constructor_band(ctx, v2.0, v104.1, v7.1);
                                                                                let v1027 = constructor_band(ctx, v2.0, v104.0, v1026);
                                                                                // Rule at src/opts/cprop.isle line 219.
                                                                                returns.extend(Some(v1027));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                &InstructionData::IntCompare {
                                                    opcode: ref v736,
                                                    args: ref v737,
                                                    cond: ref v738,
                                                } => {
                                                    if let &Opcode::Icmp = v736 {
                                                        let v16 = C::u64_from_imm64(ctx, v15);
                                                        if v16 == 0x1_u64 {
                                                            let v297 = C::ty_int(ctx, v2.0);
                                                            if let Some(v298) = v297 {
                                                                // Rule at src/opts/icmp.isle line 90.
                                                                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 v297 = C::ty_int(ctx, v2.0);
                                                                if let Some(v298) = v297 {
                                                                    let mut v636 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v30, &mut v636);
                                                                    let mut v636 = v636.into_context_iter();
                                                                    while let Some(v637) = v636.next(ctx) {
                                                                        if let &InstructionData::IntCompare {
                                                                            opcode: ref v1418,
                                                                            args: ref v1419,
                                                                            cond: ref v1420,
                                                                        } = &v637.1 {
                                                                            if let &Opcode::Icmp = v1418 {
                                                                                // Rule at src/opts/icmp.isle line 95.
                                                                                returns.extend(Some(v7.0));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            let v1316 = C::value_type(ctx, v30);
                                                            let v1317 = C::ty_mask(ctx, v1316);
                                                            let v1318 = C::u64_and(ctx, v16, v1317);
                                                            let v1319 = C::u64_eq(ctx, v1317, v1318);
                                                            if v1319 == 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 v1316 = C::value_type(ctx, v30);
                                                            let v1317 = C::ty_mask(ctx, v1316);
                                                            let v1320 = C::u64_eq(ctx, v16, v1317);
                                                            if v1320 == true {
                                                                let v1321 = constructor_uextend(ctx, v2.0, v30);
                                                                // Rule at src/opts/extends.isle line 22.
                                                                returns.extend(Some(v1321));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                &InstructionData::UnaryImm {
                                                    opcode: ref v22,
                                                    imm: v23,
                                                } => {
                                                    if let &Opcode::Iconst = v22 {
                                                        let v292 = C::fits_in_64(ctx, v2.0);
                                                        if let Some(v293) = v292 {
                                                            if v11.0 == v19.0 {
                                                                if v11.0 == v293 {
                                                                    let v937 = C::imm64_and(ctx, v293, v23, v15);
                                                                    let v938 = constructor_iconst(ctx, v293, v937);
                                                                    let v939 = C::subsume(ctx, v938);
                                                                    // Rule at src/opts/cprop.isle line 61.
                                                                    returns.extend(Some(v939));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                _ => {}
                                            }
                                        }
                                        let v16 = C::u64_from_imm64(ctx, v15);
                                        if v16 == 0x0_u64 {
                                            let v301 = C::ty_int_vec128(ctx, v2.0);
                                            if let Some(v302) = v301 {
                                                if v11.0 == v302 {
                                                    let v55 = C::subsume(ctx, v7.1);
                                                    // Rule at src/opts/bitops.isle line 33.
                                                    returns.extend(Some(v55));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        let v1572 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 13.
                                        returns.extend(Some(v1572));
                                        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 v102,
                                    args: ref v103,
                                } => {
                                    match v102 {
                                        &Opcode::Band => {
                                            if v2.0 == v19.0 {
                                                let v104 = C::unpack_value_array_2(ctx, v103);
                                                if v7.1 == v104.0 {
                                                    let v143 = constructor_band(ctx, v2.0, v104.0, v104.1);
                                                    // Rule at src/opts/bitops.isle line 192.
                                                    returns.extend(Some(v143));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.1 == v104.1 {
                                                    let v143 = constructor_band(ctx, v2.0, v104.0, v104.1);
                                                    // Rule at src/opts/bitops.isle line 193.
                                                    returns.extend(Some(v143));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        &Opcode::Bor => {
                                            if v2.0 == v19.0 {
                                                let v104 = C::unpack_value_array_2(ctx, v103);
                                                let mut v107 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v104.0, &mut v107);
                                                let mut v107 = v107.into_context_iter();
                                                while let Some(v108) = v107.next(ctx) {
                                                    match &v108.1 {
                                                        &InstructionData::Binary {
                                                            opcode: ref v342,
                                                            args: ref v343,
                                                        } => {
                                                            if let &Opcode::Band = v342 {
                                                                if v2.0 == v108.0 {
                                                                    let v344 = C::unpack_value_array_2(ctx, v343);
                                                                    if v7.1 == v344.0 {
                                                                        let v837 = constructor_bor(ctx, v2.0, v104.1, v344.1);
                                                                        let v838 = constructor_band(ctx, v2.0, v837, v344.0);
                                                                        // Rule at src/opts/bitops.isle line 508.
                                                                        returns.extend(Some(v838));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v7.1 == v344.1 {
                                                                        let v845 = constructor_bor(ctx, v2.0, v104.1, v344.0);
                                                                        let v846 = constructor_band(ctx, v2.0, v845, v344.1);
                                                                        // Rule at src/opts/bitops.isle line 512.
                                                                        returns.extend(Some(v846));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v111,
                                                            arg: v112,
                                                        } => {
                                                            if let &Opcode::Bnot = v111 {
                                                                if v7.1 == v112 {
                                                                    if v2.0 == v108.0 {
                                                                        let v850 = constructor_band(ctx, v2.0, v112, v104.1);
                                                                        // Rule at src/opts/bitops.isle line 527.
                                                                        returns.extend(Some(v850));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let mut v114 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                let mut v114 = v114.into_context_iter();
                                                while let Some(v115) = v114.next(ctx) {
                                                    match &v115.1 {
                                                        &InstructionData::Binary {
                                                            opcode: ref v354,
                                                            args: ref v355,
                                                        } => {
                                                            if let &Opcode::Band = v354 {
                                                                if v2.0 == v115.0 {
                                                                    let v356 = C::unpack_value_array_2(ctx, v355);
                                                                    if v7.1 == v356.0 {
                                                                        let v833 = constructor_bor(ctx, v2.0, v104.0, v356.1);
                                                                        let v834 = constructor_band(ctx, v2.0, v833, v356.0);
                                                                        // Rule at src/opts/bitops.isle line 506.
                                                                        returns.extend(Some(v834));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v7.1 == v356.1 {
                                                                        let v841 = constructor_bor(ctx, v2.0, v104.0, v356.0);
                                                                        let v842 = constructor_band(ctx, v2.0, v841, v356.1);
                                                                        // Rule at src/opts/bitops.isle line 510.
                                                                        returns.extend(Some(v842));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v118,
                                                            arg: v119,
                                                        } => {
                                                            if let &Opcode::Bnot = v118 {
                                                                if v7.1 == v119 {
                                                                    if v2.0 == v115.0 {
                                                                        let v852 = constructor_band(ctx, v2.0, v119, v104.0);
                                                                        // Rule at src/opts/bitops.isle line 529.
                                                                        returns.extend(Some(v852));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                if v7.1 == v104.0 {
                                                    // Rule at src/opts/bitops.isle line 249.
                                                    returns.extend(Some(v104.0));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.1 == v104.1 {
                                                    // Rule at src/opts/bitops.isle line 251.
                                                    returns.extend(Some(v104.1));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        &Opcode::Bxor => {
                                            if v2.0 == v19.0 {
                                                let v104 = C::unpack_value_array_2(ctx, v103);
                                                let mut v107 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v104.0, &mut v107);
                                                let mut v107 = v107.into_context_iter();
                                                while let Some(v108) = v107.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v111,
                                                        arg: v112,
                                                    } = &v108.1 {
                                                        if let &Opcode::Bnot = v111 {
                                                            if v2.0 == v108.0 {
                                                                if v7.1 == v112 {
                                                                    let v850 = constructor_band(ctx, v2.0, v112, v104.1);
                                                                    // Rule at src/opts/bitops.isle line 573.
                                                                    returns.extend(Some(v850));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v7.1 == v104.1 {
                                                                    let v612 = constructor_band(ctx, v2.0, v104.1, v112);
                                                                    // Rule at src/opts/bitops.isle line 199.
                                                                    returns.extend(Some(v612));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                let mut v114 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                let mut v114 = v114.into_context_iter();
                                                while let Some(v115) = v114.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v118,
                                                        arg: v119,
                                                    } = &v115.1 {
                                                        if let &Opcode::Bnot = v118 {
                                                            if v2.0 == v115.0 {
                                                                if v7.1 == v104.0 {
                                                                    let v611 = constructor_band(ctx, v2.0, v104.0, v119);
                                                                    // Rule at src/opts/bitops.isle line 198.
                                                                    returns.extend(Some(v611));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v7.1 == v119 {
                                                                    let v852 = constructor_band(ctx, v2.0, v119, v104.0);
                                                                    // Rule at src/opts/bitops.isle line 575.
                                                                    returns.extend(Some(v852));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v29,
                                    arg: v30,
                                } => {
                                    if let &Opcode::Bnot = v29 {
                                        if v2.0 == v19.0 {
                                            let mut v636 = C::inst_data_value_etor_returns::default();
                                            C::inst_data_value_etor(ctx, v30, &mut v636);
                                            let mut v636 = v636.into_context_iter();
                                            while let Some(v637) = v636.next(ctx) {
                                                if let &InstructionData::Binary {
                                                    opcode: ref v640,
                                                    args: ref v641,
                                                } = &v637.1 {
                                                    match v640 {
                                                        &Opcode::Band => {
                                                            if v2.0 == v637.0 {
                                                                let v642 = C::unpack_value_array_2(ctx, v641);
                                                                if v7.1 == v642.0 {
                                                                    let v725 = constructor_bnot(ctx, v2.0, v642.1);
                                                                    let v730 = constructor_band(ctx, v2.0, v642.0, v725);
                                                                    // Rule at src/opts/bitops.isle line 322.
                                                                    returns.extend(Some(v730));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v7.1 == v642.1 {
                                                                    let v721 = constructor_bnot(ctx, v2.0, v642.0);
                                                                    let v728 = constructor_band(ctx, v2.0, v642.1, v721);
                                                                    // Rule at src/opts/bitops.isle line 320.
                                                                    returns.extend(Some(v728));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                        &Opcode::Bxor => {
                                                            if v2.0 == v637.0 {
                                                                let v642 = C::unpack_value_array_2(ctx, v641);
                                                                if v7.1 == v642.0 {
                                                                    let v855 = constructor_band(ctx, v2.0, v642.0, v642.1);
                                                                    // Rule at src/opts/bitops.isle line 567.
                                                                    returns.extend(Some(v855));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v7.1 == v642.1 {
                                                                    let v856 = constructor_band(ctx, v2.0, v642.1, v642.0);
                                                                    // Rule at src/opts/bitops.isle line 569.
                                                                    returns.extend(Some(v856));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                            }
                                        }
                                        if v7.1 == v30 {
                                            let v301 = C::ty_int_vec128(ctx, v2.0);
                                            if let Some(v302) = v301 {
                                                if v19.0 == v302 {
                                                    let v305 = constructor_iconst_u(ctx, v302, 0x0_u64);
                                                    let v306 = C::subsume(ctx, v305);
                                                    // Rule at src/opts/bitops.isle line 35.
                                                    returns.extend(Some(v306));
                                                    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 v997 = constructor_band(ctx, v2.0, v7.1, v7.0);
                                            // Rule at src/opts/cprop.isle line 161.
                                            returns.extend(Some(v997));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        let v1572 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 11.
                                        returns.extend(Some(v1572));
                                        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 v56 = C::inst_data_value_tupled_etor_returns::default();
                        C::inst_data_value_tupled_etor(ctx, v7.1, &mut v56);
                        let mut v56 = v56.into_context_iter();
                        while let Some(v57) = v56.next(ctx) {
                            let v58 = C::iconst_sextend_etor(ctx, v57);
                            if let Some(v59) = v58 {
                                if v59.1 == -1_i64 {
                                    if v2.0 == v59.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 v138,
                                    args: ref v139,
                                } => {
                                    match v138 {
                                        &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) {
                                                    match &v19.1 {
                                                        &InstructionData::Binary {
                                                            opcode: ref v102,
                                                            args: ref v103,
                                                        } => {
                                                            if let &Opcode::Band = v102 {
                                                                if v2.0 == v19.0 {
                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let v140 = C::unpack_value_array_2(ctx, v139);
                                                                    if v104.0 == v140.0 {
                                                                        let mut v114 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                                        let mut v114 = v114.into_context_iter();
                                                                        while let Some(v115) = v114.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v118,
                                                                                arg: v119,
                                                                            } = &v115.1 {
                                                                                if let &Opcode::Bnot = v118 {
                                                                                    if v2.0 == v115.0 {
                                                                                        if v119 == v140.1 {
                                                                                            // Rule at src/opts/bitops.isle line 465.
                                                                                            returns.extend(Some(v104.0));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let mut v414 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v140.1, &mut v414);
                                                                        let mut v414 = v414.into_context_iter();
                                                                        while let Some(v415) = v414.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v613,
                                                                                arg: v614,
                                                                            } = &v415.1 {
                                                                                if let &Opcode::Bnot = v613 {
                                                                                    if v104.1 == v614 {
                                                                                        if v2.0 == v415.0 {
                                                                                            // Rule at src/opts/bitops.isle line 464.
                                                                                            returns.extend(Some(v104.0));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let v683 = constructor_bor(ctx, v2.0, v104.1, v140.1);
                                                                        let v684 = constructor_band(ctx, v2.0, v683, v104.0);
                                                                        // Rule at src/opts/bitops.isle line 271.
                                                                        returns.extend(Some(v684));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        let v685 = constructor_bor(ctx, v2.0, v140.1, v104.1);
                                                                        let v686 = constructor_band(ctx, v2.0, v685, v104.0);
                                                                        // Rule at src/opts/bitops.isle line 272.
                                                                        returns.extend(Some(v686));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        let mut v114 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                                        let mut v114 = v114.into_context_iter();
                                                                        while let Some(v115) = v114.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v118,
                                                                                arg: v119,
                                                                            } = &v115.1 {
                                                                                if let &Opcode::Bnot = v118 {
                                                                                    if v119 == v140.0 {
                                                                                        if v2.0 == v115.0 {
                                                                                            // Rule at src/opts/bitops.isle line 469.
                                                                                            returns.extend(Some(v104.0));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let mut v382 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v140.0, &mut v382);
                                                                        let mut v382 = v382.into_context_iter();
                                                                        while let Some(v383) = v382.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v616,
                                                                                arg: v617,
                                                                            } = &v383.1 {
                                                                                if let &Opcode::Bnot = v616 {
                                                                                    if v104.1 == v617 {
                                                                                        if v2.0 == v383.0 {
                                                                                            // Rule at src/opts/bitops.isle line 466.
                                                                                            returns.extend(Some(v104.0));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let v677 = constructor_bor(ctx, v2.0, v140.0, v104.1);
                                                                        let v678 = constructor_band(ctx, v2.0, v677, v104.0);
                                                                        // Rule at src/opts/bitops.isle line 268.
                                                                        returns.extend(Some(v678));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        let v679 = constructor_bor(ctx, v2.0, v104.1, v140.0);
                                                                        let v680 = constructor_band(ctx, v2.0, v679, v104.0);
                                                                        // Rule at src/opts/bitops.isle line 269.
                                                                        returns.extend(Some(v680));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v104.1 == v140.0 {
                                                                        let mut v107 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v104.0, &mut v107);
                                                                        let mut v107 = v107.into_context_iter();
                                                                        while let Some(v108) = v107.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v111,
                                                                                arg: v112,
                                                                            } = &v108.1 {
                                                                                if let &Opcode::Bnot = v111 {
                                                                                    if v112 == v140.1 {
                                                                                        if v2.0 == v108.0 {
                                                                                            // Rule at src/opts/bitops.isle line 467.
                                                                                            returns.extend(Some(v104.1));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let mut v414 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v140.1, &mut v414);
                                                                        let mut v414 = v414.into_context_iter();
                                                                        while let Some(v415) = v414.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v613,
                                                                                arg: v614,
                                                                            } = &v415.1 {
                                                                                if let &Opcode::Bnot = v613 {
                                                                                    if v104.0 == v614 {
                                                                                        if v2.0 == v415.0 {
                                                                                            // Rule at src/opts/bitops.isle line 468.
                                                                                            returns.extend(Some(v104.1));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let v675 = constructor_bor(ctx, v2.0, v104.0, v140.1);
                                                                        let v676 = constructor_band(ctx, v2.0, v675, v104.1);
                                                                        // Rule at src/opts/bitops.isle line 267.
                                                                        returns.extend(Some(v676));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        let v681 = constructor_bor(ctx, v2.0, v140.1, v104.0);
                                                                        let v682 = constructor_band(ctx, v2.0, v681, v104.1);
                                                                        // Rule at src/opts/bitops.isle line 270.
                                                                        returns.extend(Some(v682));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v104.1 == v140.1 {
                                                                        let mut v107 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v104.0, &mut v107);
                                                                        let mut v107 = v107.into_context_iter();
                                                                        while let Some(v108) = v107.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v111,
                                                                                arg: v112,
                                                                            } = &v108.1 {
                                                                                if let &Opcode::Bnot = v111 {
                                                                                    if v112 == v140.0 {
                                                                                        if v2.0 == v108.0 {
                                                                                            // Rule at src/opts/bitops.isle line 471.
                                                                                            returns.extend(Some(v104.1));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let mut v382 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v140.0, &mut v382);
                                                                        let mut v382 = v382.into_context_iter();
                                                                        while let Some(v383) = v382.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v616,
                                                                                arg: v617,
                                                                            } = &v383.1 {
                                                                                if let &Opcode::Bnot = v616 {
                                                                                    if v104.0 == v617 {
                                                                                        if v2.0 == v383.0 {
                                                                                            // Rule at src/opts/bitops.isle line 470.
                                                                                            returns.extend(Some(v104.1));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let v671 = constructor_bor(ctx, v2.0, v104.0, v140.0);
                                                                        let v672 = constructor_band(ctx, v2.0, v671, v104.1);
                                                                        // Rule at src/opts/bitops.isle line 265.
                                                                        returns.extend(Some(v672));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        let v673 = constructor_bor(ctx, v2.0, v140.0, v104.0);
                                                                        let v674 = constructor_band(ctx, v2.0, v673, v104.1);
                                                                        // Rule at src/opts/bitops.isle line 266.
                                                                        returns.extend(Some(v674));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v29,
                                                            arg: v30,
                                                        } => {
                                                            if let &Opcode::Bnot = v29 {
                                                                if v2.0 == v19.0 {
                                                                    let mut v636 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v30, &mut v636);
                                                                    let mut v636 = v636.into_context_iter();
                                                                    while let Some(v637) = v636.next(ctx) {
                                                                        if let &InstructionData::Binary {
                                                                            opcode: ref v640,
                                                                            args: ref v641,
                                                                        } = &v637.1 {
                                                                            match v640 {
                                                                                &Opcode::Bor => {
                                                                                    if v2.0 == v637.0 {
                                                                                        let v140 = C::unpack_value_array_2(ctx, v139);
                                                                                        let v642 = C::unpack_value_array_2(ctx, v641);
                                                                                        if v140.0 == v642.0 {
                                                                                            if v140.1 == v642.1 {
                                                                                                let v645 = constructor_bxor(ctx, v2.0, v642.0, v642.1);
                                                                                                let v646 = constructor_bnot(ctx, v2.0, v645);
                                                                                                // Rule at src/opts/bitops.isle line 636.
                                                                                                returns.extend(Some(v646));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v647 = constructor_bxor(ctx, v2.0, v642.1, v642.0);
                                                                                                let v648 = constructor_bnot(ctx, v2.0, v647);
                                                                                                // Rule at src/opts/bitops.isle line 642.
                                                                                                returns.extend(Some(v648));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                            let mut v414 = C::inst_data_value_etor_returns::default();
                                                                                            C::inst_data_value_etor(ctx, v140.1, &mut v414);
                                                                                            let mut v414 = v414.into_context_iter();
                                                                                            while let Some(v415) = v414.next(ctx) {
                                                                                                if let &InstructionData::Unary {
                                                                                                    opcode: ref v613,
                                                                                                    arg: v614,
                                                                                                } = &v415.1 {
                                                                                                    if let &Opcode::Bnot = v613 {
                                                                                                        if v614 == v642.1 {
                                                                                                            if v2.0 == v415.0 {
                                                                                                                let v725 = constructor_bnot(ctx, v2.0, v642.1);
                                                                                                                // Rule at src/opts/bitops.isle line 622.
                                                                                                                returns.extend(Some(v725));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                        if v140.0 == v642.1 {
                                                                                            if v140.1 == v642.0 {
                                                                                                let v647 = constructor_bxor(ctx, v2.0, v642.1, v642.0);
                                                                                                let v648 = constructor_bnot(ctx, v2.0, v647);
                                                                                                // Rule at src/opts/bitops.isle line 638.
                                                                                                returns.extend(Some(v648));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v645 = constructor_bxor(ctx, v2.0, v642.0, v642.1);
                                                                                                let v646 = constructor_bnot(ctx, v2.0, v645);
                                                                                                // Rule at src/opts/bitops.isle line 640.
                                                                                                returns.extend(Some(v646));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                            let mut v414 = C::inst_data_value_etor_returns::default();
                                                                                            C::inst_data_value_etor(ctx, v140.1, &mut v414);
                                                                                            let mut v414 = v414.into_context_iter();
                                                                                            while let Some(v415) = v414.next(ctx) {
                                                                                                if let &InstructionData::Unary {
                                                                                                    opcode: ref v613,
                                                                                                    arg: v614,
                                                                                                } = &v415.1 {
                                                                                                    if let &Opcode::Bnot = v613 {
                                                                                                        if v614 == v642.0 {
                                                                                                            if v2.0 == v415.0 {
                                                                                                                let v721 = constructor_bnot(ctx, v2.0, v642.0);
                                                                                                                // Rule at src/opts/bitops.isle line 620.
                                                                                                                returns.extend(Some(v721));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                        let mut v382 = C::inst_data_value_etor_returns::default();
                                                                                        C::inst_data_value_etor(ctx, v140.0, &mut v382);
                                                                                        let mut v382 = v382.into_context_iter();
                                                                                        while let Some(v383) = v382.next(ctx) {
                                                                                            if let &InstructionData::Unary {
                                                                                                opcode: ref v616,
                                                                                                arg: v617,
                                                                                            } = &v383.1 {
                                                                                                if let &Opcode::Bnot = v616 {
                                                                                                    if v2.0 == v383.0 {
                                                                                                        if v617 == v642.0 {
                                                                                                            if v140.1 == v642.1 {
                                                                                                                let v721 = constructor_bnot(ctx, v2.0, v642.0);
                                                                                                                // Rule at src/opts/bitops.isle line 616.
                                                                                                                returns.extend(Some(v721));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                        if v617 == v642.1 {
                                                                                                            if v140.1 == v642.0 {
                                                                                                                let v725 = constructor_bnot(ctx, v2.0, v642.1);
                                                                                                                // Rule at src/opts/bitops.isle line 618.
                                                                                                                returns.extend(Some(v725));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                                &Opcode::Bxor => {
                                                                                    if v2.0 == v637.0 {
                                                                                        let v140 = C::unpack_value_array_2(ctx, v139);
                                                                                        let v642 = C::unpack_value_array_2(ctx, v641);
                                                                                        if v140.0 == v642.0 {
                                                                                            if v140.1 == v642.1 {
                                                                                                let v645 = constructor_bxor(ctx, v2.0, v642.0, v642.1);
                                                                                                let v646 = constructor_bnot(ctx, v2.0, v645);
                                                                                                // Rule at src/opts/bitops.isle line 230.
                                                                                                returns.extend(Some(v646));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v647 = constructor_bxor(ctx, v2.0, v642.1, v642.0);
                                                                                                let v648 = constructor_bnot(ctx, v2.0, v647);
                                                                                                // Rule at src/opts/bitops.isle line 236.
                                                                                                returns.extend(Some(v648));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                        if v140.0 == v642.1 {
                                                                                            if v140.1 == v642.0 {
                                                                                                let v647 = constructor_bxor(ctx, v2.0, v642.1, v642.0);
                                                                                                let v648 = constructor_bnot(ctx, v2.0, v647);
                                                                                                // Rule at src/opts/bitops.isle line 232.
                                                                                                returns.extend(Some(v648));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v645 = constructor_bxor(ctx, v2.0, v642.0, v642.1);
                                                                                                let v646 = constructor_bnot(ctx, v2.0, v645);
                                                                                                // Rule at src/opts/bitops.isle line 234.
                                                                                                returns.extend(Some(v646));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                                _ => {}
                                                                            }
                                                                        }
                                                                    }
                                                                    let v140 = C::unpack_value_array_2(ctx, v139);
                                                                    if v30 == v140.0 {
                                                                        let v622 = constructor_bnot(ctx, v2.0, v30);
                                                                        let v623 = constructor_bor(ctx, v2.0, v140.1, v622);
                                                                        // Rule at src/opts/bitops.isle line 221.
                                                                        returns.extend(Some(v623));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v30 == v140.1 {
                                                                        let v308 = constructor_bor(ctx, v2.0, v140.0, v7.0);
                                                                        // Rule at src/opts/bitops.isle line 53.
                                                                        returns.extend(Some(v308));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let v140 = C::unpack_value_array_2(ctx, v139);
                                                let mut v382 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v140.0, &mut v382);
                                                let mut v382 = v382.into_context_iter();
                                                while let Some(v383) = v382.next(ctx) {
                                                    match &v383.1 {
                                                        &InstructionData::Binary {
                                                            opcode: ref v386,
                                                            args: ref v387,
                                                        } => {
                                                            match v386 {
                                                                &Opcode::Bor => {
                                                                    if v2.0 == v383.0 {
                                                                        let v388 = C::unpack_value_array_2(ctx, v387);
                                                                        if v7.0 == v388.0 {
                                                                            let v823 = constructor_band(ctx, v2.0, v140.1, v388.1);
                                                                            let v824 = constructor_bor(ctx, v2.0, v823, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 499.
                                                                            returns.extend(Some(v824));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.0 == v388.1 {
                                                                            let v831 = constructor_band(ctx, v2.0, v140.1, v388.0);
                                                                            let v832 = constructor_bor(ctx, v2.0, v831, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 503.
                                                                            returns.extend(Some(v832));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Bxor => {
                                                                    if v2.0 == v383.0 {
                                                                        let v388 = C::unpack_value_array_2(ctx, v387);
                                                                        if v7.0 == v388.0 {
                                                                            let v793 = constructor_band(ctx, v2.0, v388.1, v140.1);
                                                                            let v794 = constructor_bor(ctx, v2.0, v793, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 439.
                                                                            returns.extend(Some(v794));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.0 == v388.1 {
                                                                            let v785 = constructor_band(ctx, v2.0, v388.0, v140.1);
                                                                            let v786 = constructor_bor(ctx, v2.0, v785, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 435.
                                                                            returns.extend(Some(v786));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v616,
                                                            arg: v617,
                                                        } => {
                                                            if let &Opcode::Bnot = v616 {
                                                                if v7.0 == v617 {
                                                                    if v2.0 == v383.0 {
                                                                        let v608 = constructor_bor(ctx, v2.0, v7.0, v140.1);
                                                                        // Rule at src/opts/bitops.isle line 532.
                                                                        returns.extend(Some(v608));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let mut v414 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v140.1, &mut v414);
                                                let mut v414 = v414.into_context_iter();
                                                while let Some(v415) = v414.next(ctx) {
                                                    match &v415.1 {
                                                        &InstructionData::Binary {
                                                            opcode: ref v418,
                                                            args: ref v419,
                                                        } => {
                                                            match v418 {
                                                                &Opcode::Bor => {
                                                                    if v2.0 == v415.0 {
                                                                        let v420 = C::unpack_value_array_2(ctx, v419);
                                                                        if v7.0 == v420.0 {
                                                                            let v819 = constructor_band(ctx, v2.0, v140.0, v420.1);
                                                                            let v820 = constructor_bor(ctx, v2.0, v819, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 497.
                                                                            returns.extend(Some(v820));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.0 == v420.1 {
                                                                            let v827 = constructor_band(ctx, v2.0, v140.0, v420.0);
                                                                            let v828 = constructor_bor(ctx, v2.0, v827, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 501.
                                                                            returns.extend(Some(v828));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Bxor => {
                                                                    if v2.0 == v415.0 {
                                                                        let v420 = C::unpack_value_array_2(ctx, v419);
                                                                        if v7.0 == v420.0 {
                                                                            let v797 = constructor_band(ctx, v2.0, v420.1, v140.0);
                                                                            let v798 = constructor_bor(ctx, v2.0, v797, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 441.
                                                                            returns.extend(Some(v798));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.0 == v420.1 {
                                                                            let v789 = constructor_band(ctx, v2.0, v420.0, v140.0);
                                                                            let v790 = constructor_bor(ctx, v2.0, v789, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 437.
                                                                            returns.extend(Some(v790));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v613,
                                                            arg: v614,
                                                        } => {
                                                            if let &Opcode::Bnot = v613 {
                                                                if v7.0 == v614 {
                                                                    if v2.0 == v415.0 {
                                                                        let v772 = constructor_bor(ctx, v2.0, v7.0, v140.0);
                                                                        // Rule at src/opts/bitops.isle line 534.
                                                                        returns.extend(Some(v772));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                if v7.0 == v140.0 {
                                                    // Rule at src/opts/bitops.isle line 213.
                                                    returns.extend(Some(v7.0));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                            let v1063 = C::ty_vec128(ctx, v2.0);
                                            if let Some(v1064) = v1063 {
                                                if v11.0 == v1064 {
                                                    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 v102,
                                                            args: ref v103,
                                                        } = &v19.1 {
                                                            if let &Opcode::Band = v102 {
                                                                if v11.0 == v19.0 {
                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let mut v107 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v104.0, &mut v107);
                                                                    let mut v107 = v107.into_context_iter();
                                                                    while let Some(v108) = v107.next(ctx) {
                                                                        if let &InstructionData::Unary {
                                                                            opcode: ref v111,
                                                                            arg: v112,
                                                                        } = &v108.1 {
                                                                            if let &Opcode::Bnot = v111 {
                                                                                if v11.0 == v108.0 {
                                                                                    let v140 = C::unpack_value_array_2(ctx, v139);
                                                                                    if v112 == v140.0 {
                                                                                        let v1616 = constructor_bitselect(ctx, v1064, v112, v140.1, v104.1);
                                                                                        // Rule at src/opts/selects.isle line 73.
                                                                                        returns.extend(Some(v1616));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v112 == v140.1 {
                                                                                        let v1617 = constructor_bitselect(ctx, v1064, v112, v140.0, v104.1);
                                                                                        // Rule at src/opts/selects.isle line 74.
                                                                                        returns.extend(Some(v1617));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    let mut v114 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                                    let mut v114 = v114.into_context_iter();
                                                                    while let Some(v115) = v114.next(ctx) {
                                                                        if let &InstructionData::Unary {
                                                                            opcode: ref v118,
                                                                            arg: v119,
                                                                        } = &v115.1 {
                                                                            if let &Opcode::Bnot = v118 {
                                                                                if v11.0 == v115.0 {
                                                                                    let v140 = C::unpack_value_array_2(ctx, v139);
                                                                                    if v119 == v140.0 {
                                                                                        let v1618 = constructor_bitselect(ctx, v1064, v119, v140.1, v104.0);
                                                                                        // Rule at src/opts/selects.isle line 75.
                                                                                        returns.extend(Some(v1618));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v119 == v140.1 {
                                                                                        let v1619 = constructor_bitselect(ctx, v1064, v119, v140.0, v104.0);
                                                                                        // Rule at src/opts/selects.isle line 76.
                                                                                        returns.extend(Some(v1619));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    let v140 = C::unpack_value_array_2(ctx, v139);
                                                                    let mut v382 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v140.0, &mut v382);
                                                                    let mut v382 = v382.into_context_iter();
                                                                    while let Some(v383) = v382.next(ctx) {
                                                                        if let &InstructionData::Unary {
                                                                            opcode: ref v616,
                                                                            arg: v617,
                                                                        } = &v383.1 {
                                                                            if let &Opcode::Bnot = v616 {
                                                                                if v11.0 == v383.0 {
                                                                                    if v104.0 == v617 {
                                                                                        let v1612 = constructor_bitselect(ctx, v1064, v104.0, v104.1, v140.1);
                                                                                        // Rule at src/opts/selects.isle line 69.
                                                                                        returns.extend(Some(v1612));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v104.1 == v617 {
                                                                                        let v1614 = constructor_bitselect(ctx, v1064, v104.1, v104.0, v140.1);
                                                                                        // Rule at src/opts/selects.isle line 71.
                                                                                        returns.extend(Some(v1614));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    let mut v414 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v140.1, &mut v414);
                                                                    let mut v414 = v414.into_context_iter();
                                                                    while let Some(v415) = v414.next(ctx) {
                                                                        if let &InstructionData::Unary {
                                                                            opcode: ref v613,
                                                                            arg: v614,
                                                                        } = &v415.1 {
                                                                            if let &Opcode::Bnot = v613 {
                                                                                if v11.0 == v415.0 {
                                                                                    if v104.0 == v614 {
                                                                                        let v1613 = constructor_bitselect(ctx, v1064, v104.0, v104.1, v140.0);
                                                                                        // Rule at src/opts/selects.isle line 70.
                                                                                        returns.extend(Some(v1613));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v104.1 == v614 {
                                                                                        let v1615 = constructor_bitselect(ctx, v1064, v104.1, v104.0, v140.0);
                                                                                        // Rule at src/opts/selects.isle line 72.
                                                                                        returns.extend(Some(v1615));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Bor => {
                                            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 v102,
                                                        args: ref v103,
                                                    } = &v19.1 {
                                                        match v102 {
                                                            &Opcode::Bor => {
                                                                if v2.0 == v19.0 {
                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let mut v114 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                                    let mut v114 = v114.into_context_iter();
                                                                    while let Some(v115) = v114.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v132,
                                                                            imm: v133,
                                                                        } = &v115.1 {
                                                                            if let &Opcode::Iconst = v132 {
                                                                                let v140 = C::unpack_value_array_2(ctx, v139);
                                                                                let mut v414 = C::inst_data_value_etor_returns::default();
                                                                                C::inst_data_value_etor(ctx, v140.1, &mut v414);
                                                                                let mut v414 = v414.into_context_iter();
                                                                                while let Some(v415) = v414.next(ctx) {
                                                                                    if let &InstructionData::UnaryImm {
                                                                                        opcode: ref v1097,
                                                                                        imm: v1098,
                                                                                    } = &v415.1 {
                                                                                        if let &Opcode::Iconst = v1097 {
                                                                                            let v671 = constructor_bor(ctx, v2.0, v104.0, v140.0);
                                                                                            let v1107 = constructor_bor(ctx, v2.0, v104.1, v140.1);
                                                                                            let v1108 = constructor_bor(ctx, v2.0, v671, v1107);
                                                                                            // Rule at src/opts/cprop.isle line 325.
                                                                                            returns.extend(Some(v1108));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Bxor => {
                                                                if v2.0 == v19.0 {
                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let v140 = C::unpack_value_array_2(ctx, v139);
                                                                    if v104.0 == v140.0 {
                                                                        if v104.1 == v140.1 {
                                                                            let v245 = constructor_bor(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/bitops.isle line 579.
                                                                            returns.extend(Some(v245));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            let v246 = constructor_bor(ctx, v2.0, v104.1, v104.0);
                                                                            // Rule at src/opts/bitops.isle line 585.
                                                                            returns.extend(Some(v246));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        let v681 = constructor_bor(ctx, v2.0, v140.1, v104.0);
                                                                        let v777 = constructor_bor(ctx, v2.0, v681, v104.1);
                                                                        // Rule at src/opts/bitops.isle line 416.
                                                                        returns.extend(Some(v777));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        let v675 = constructor_bor(ctx, v2.0, v104.0, v140.1);
                                                                        let v799 = constructor_bor(ctx, v2.0, v675, v104.1);
                                                                        // Rule at src/opts/bitops.isle line 445.
                                                                        returns.extend(Some(v799));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        if v104.1 == v140.0 {
                                                                            let v246 = constructor_bor(ctx, v2.0, v104.1, v104.0);
                                                                            // Rule at src/opts/bitops.isle line 581.
                                                                            returns.extend(Some(v246));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            let v245 = constructor_bor(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/bitops.isle line 583.
                                                                            returns.extend(Some(v245));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        let v673 = constructor_bor(ctx, v2.0, v140.0, v104.0);
                                                                        let v775 = constructor_bor(ctx, v2.0, v673, v104.1);
                                                                        // Rule at src/opts/bitops.isle line 414.
                                                                        returns.extend(Some(v775));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        let v671 = constructor_bor(ctx, v2.0, v104.0, v140.0);
                                                                        let v801 = constructor_bor(ctx, v2.0, v671, v104.1);
                                                                        // Rule at src/opts/bitops.isle line 449.
                                                                        returns.extend(Some(v801));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v104.1 == v140.0 {
                                                                        let v685 = constructor_bor(ctx, v2.0, v140.1, v104.1);
                                                                        let v781 = constructor_bor(ctx, v2.0, v685, v104.0);
                                                                        // Rule at src/opts/bitops.isle line 420.
                                                                        returns.extend(Some(v781));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        let v683 = constructor_bor(ctx, v2.0, v104.1, v140.1);
                                                                        let v800 = constructor_bor(ctx, v2.0, v683, v104.0);
                                                                        // Rule at src/opts/bitops.isle line 447.
                                                                        returns.extend(Some(v800));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v104.1 == v140.1 {
                                                                        let v677 = constructor_bor(ctx, v2.0, v140.0, v104.1);
                                                                        let v779 = constructor_bor(ctx, v2.0, v677, v104.0);
                                                                        // Rule at src/opts/bitops.isle line 418.
                                                                        returns.extend(Some(v779));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        let v679 = constructor_bor(ctx, v2.0, v104.1, v140.0);
                                                                        let v802 = constructor_bor(ctx, v2.0, v679, v104.0);
                                                                        // Rule at src/opts/bitops.isle line 451.
                                                                        returns.extend(Some(v802));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                    }
                                                }
                                                let v140 = C::unpack_value_array_2(ctx, v139);
                                                if v7.0 == v140.0 {
                                                    let v608 = constructor_bor(ctx, v2.0, v7.0, v140.1);
                                                    // Rule at src/opts/bitops.isle line 189.
                                                    returns.extend(Some(v608));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.0 == v140.1 {
                                                    let v308 = constructor_bor(ctx, v2.0, v140.0, v7.0);
                                                    // Rule at src/opts/bitops.isle line 190.
                                                    returns.extend(Some(v308));
                                                    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 v102,
                                                                    args: ref v103,
                                                                } = &v19.1 {
                                                                    if let &Opcode::Bor = v102 {
                                                                        let v104 = C::unpack_value_array_2(ctx, v103);
                                                                        let mut v107 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v104.0, &mut v107);
                                                                        let mut v107 = v107.into_context_iter();
                                                                        while let Some(v108) = v107.next(ctx) {
                                                                            if v108.0 == I32 {
                                                                                if let &InstructionData::Binary {
                                                                                    opcode: ref v342,
                                                                                    args: ref v343,
                                                                                } = &v108.1 {
                                                                                    if let &Opcode::Ishl = v342 {
                                                                                        let mut v114 = C::inst_data_value_etor_returns::default();
                                                                                        C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                                                        let mut v114 = v114.into_context_iter();
                                                                                        while let Some(v115) = v114.next(ctx) {
                                                                                            if v115.0 == I32 {
                                                                                                if let &InstructionData::Binary {
                                                                                                    opcode: ref v354,
                                                                                                    args: ref v355,
                                                                                                } = &v115.1 {
                                                                                                    if let &Opcode::Ishl = v354 {
                                                                                                        let v344 = C::unpack_value_array_2(ctx, v343);
                                                                                                        let mut v347 = C::inst_data_value_etor_returns::default();
                                                                                                        C::inst_data_value_etor(ctx, v344.1, &mut v347);
                                                                                                        let mut v347 = v347.into_context_iter();
                                                                                                        while let Some(v348) = v347.next(ctx) {
                                                                                                            if v348.0 == I32 {
                                                                                                                if let &InstructionData::UnaryImm {
                                                                                                                    opcode: ref v351,
                                                                                                                    imm: v352,
                                                                                                                } = &v348.1 {
                                                                                                                    if let &Opcode::Iconst = v351 {
                                                                                                                        let v353 = C::u64_from_imm64(ctx, v352);
                                                                                                                        if v353 == 0x18_u64 {
                                                                                                                            let v356 = C::unpack_value_array_2(ctx, v355);
                                                                                                                            let mut v359 = C::inst_data_value_etor_returns::default();
                                                                                                                            C::inst_data_value_etor(ctx, v356.0, &mut v359);
                                                                                                                            let mut v359 = v359.into_context_iter();
                                                                                                                            while let Some(v360) = v359.next(ctx) {
                                                                                                                                if v360.0 == I32 {
                                                                                                                                    if let &InstructionData::Binary {
                                                                                                                                        opcode: ref v363,
                                                                                                                                        args: ref v364,
                                                                                                                                    } = &v360.1 {
                                                                                                                                        if let &Opcode::Band = v363 {
                                                                                                                                            let v365 = C::unpack_value_array_2(ctx, v364);
                                                                                                                                            if v344.0 == v365.0 {
                                                                                                                                                let mut v368 = C::inst_data_value_etor_returns::default();
                                                                                                                                                C::inst_data_value_etor(ctx, v365.1, &mut v368);
                                                                                                                                                let mut v368 = v368.into_context_iter();
                                                                                                                                                while let Some(v369) = v368.next(ctx) {
                                                                                                                                                    if v369.0 == I32 {
                                                                                                                                                        if let &InstructionData::UnaryImm {
                                                                                                                                                            opcode: ref v372,
                                                                                                                                                            imm: v373,
                                                                                                                                                        } = &v369.1 {
                                                                                                                                                            if let &Opcode::Iconst = v372 {
                                                                                                                                                                let v374 = C::u64_from_imm64(ctx, v373);
                                                                                                                                                                if v374 == 0xff00_u64 {
                                                                                                                                                                    let mut v375 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                    C::inst_data_value_etor(ctx, v356.1, &mut v375);
                                                                                                                                                                    let mut v375 = v375.into_context_iter();
                                                                                                                                                                    while let Some(v376) = v375.next(ctx) {
                                                                                                                                                                        if v376.0 == I32 {
                                                                                                                                                                            if let &InstructionData::UnaryImm {
                                                                                                                                                                                opcode: ref v379,
                                                                                                                                                                                imm: v380,
                                                                                                                                                                            } = &v376.1 {
                                                                                                                                                                                if let &Opcode::Iconst = v379 {
                                                                                                                                                                                    let v381 = C::u64_from_imm64(ctx, v380);
                                                                                                                                                                                    if v381 == 0x8_u64 {
                                                                                                                                                                                        let v140 = C::unpack_value_array_2(ctx, v139);
                                                                                                                                                                                        let mut v382 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                        C::inst_data_value_etor(ctx, v140.0, &mut v382);
                                                                                                                                                                                        let mut v382 = v382.into_context_iter();
                                                                                                                                                                                        while let Some(v383) = v382.next(ctx) {
                                                                                                                                                                                            if v383.0 == I32 {
                                                                                                                                                                                                if let &InstructionData::Binary {
                                                                                                                                                                                                    opcode: ref v386,
                                                                                                                                                                                                    args: ref v387,
                                                                                                                                                                                                } = &v383.1 {
                                                                                                                                                                                                    if let &Opcode::Band = v386 {
                                                                                                                                                                                                        let v388 = C::unpack_value_array_2(ctx, v387);
                                                                                                                                                                                                        let mut v391 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                        C::inst_data_value_etor(ctx, v388.0, &mut v391);
                                                                                                                                                                                                        let mut v391 = v391.into_context_iter();
                                                                                                                                                                                                        while let Some(v392) = v391.next(ctx) {
                                                                                                                                                                                                            if v392.0 == I32 {
                                                                                                                                                                                                                if let &InstructionData::Binary {
                                                                                                                                                                                                                    opcode: ref v395,
                                                                                                                                                                                                                    args: ref v396,
                                                                                                                                                                                                                } = &v392.1 {
                                                                                                                                                                                                                    if let &Opcode::Ushr = v395 {
                                                                                                                                                                                                                        let v397 = C::unpack_value_array_2(ctx, v396);
                                                                                                                                                                                                                        if v344.0 == v397.0 {
                                                                                                                                                                                                                            let mut v400 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                            C::inst_data_value_etor(ctx, v397.1, &mut v400);
                                                                                                                                                                                                                            let mut v400 = v400.into_context_iter();
                                                                                                                                                                                                                            while let Some(v401) = v400.next(ctx) {
                                                                                                                                                                                                                                if v401.0 == I32 {
                                                                                                                                                                                                                                    if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                        opcode: ref v404,
                                                                                                                                                                                                                                        imm: v405,
                                                                                                                                                                                                                                    } = &v401.1 {
                                                                                                                                                                                                                                        if let &Opcode::Iconst = v404 {
                                                                                                                                                                                                                                            let v406 = C::u64_from_imm64(ctx, v405);
                                                                                                                                                                                                                                            if v406 == 0x8_u64 {
                                                                                                                                                                                                                                                let mut v407 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                C::inst_data_value_etor(ctx, v388.1, &mut v407);
                                                                                                                                                                                                                                                let mut v407 = v407.into_context_iter();
                                                                                                                                                                                                                                                while let Some(v408) = v407.next(ctx) {
                                                                                                                                                                                                                                                    if v408.0 == I32 {
                                                                                                                                                                                                                                                        if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                            opcode: ref v411,
                                                                                                                                                                                                                                                            imm: v412,
                                                                                                                                                                                                                                                        } = &v408.1 {
                                                                                                                                                                                                                                                            if let &Opcode::Iconst = v411 {
                                                                                                                                                                                                                                                                let v413 = C::u64_from_imm64(ctx, v412);
                                                                                                                                                                                                                                                                if v413 == 0xff00_u64 {
                                                                                                                                                                                                                                                                    let mut v414 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                    C::inst_data_value_etor(ctx, v140.1, &mut v414);
                                                                                                                                                                                                                                                                    let mut v414 = v414.into_context_iter();
                                                                                                                                                                                                                                                                    while let Some(v415) = v414.next(ctx) {
                                                                                                                                                                                                                                                                        if v415.0 == I32 {
                                                                                                                                                                                                                                                                            if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                                opcode: ref v418,
                                                                                                                                                                                                                                                                                args: ref v419,
                                                                                                                                                                                                                                                                            } = &v415.1 {
                                                                                                                                                                                                                                                                                if let &Opcode::Ushr = v418 {
                                                                                                                                                                                                                                                                                    let v420 = C::unpack_value_array_2(ctx, v419);
                                                                                                                                                                                                                                                                                    if v344.0 == v420.0 {
                                                                                                                                                                                                                                                                                        let mut v423 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                        C::inst_data_value_etor(ctx, v420.1, &mut v423);
                                                                                                                                                                                                                                                                                        let mut v423 = v423.into_context_iter();
                                                                                                                                                                                                                                                                                        while let Some(v424) = v423.next(ctx) {
                                                                                                                                                                                                                                                                                            if v424.0 == I32 {
                                                                                                                                                                                                                                                                                                if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                    opcode: ref v427,
                                                                                                                                                                                                                                                                                                    imm: v428,
                                                                                                                                                                                                                                                                                                } = &v424.1 {
                                                                                                                                                                                                                                                                                                    if let &Opcode::Iconst = v427 {
                                                                                                                                                                                                                                                                                                        let v429 = C::u64_from_imm64(ctx, v428);
                                                                                                                                                                                                                                                                                                        if v429 == 0x18_u64 {
                                                                                                                                                                                                                                                                                                            let v430 = constructor_bswap(ctx, v2.0, v344.0);
                                                                                                                                                                                                                                                                                                            // Rule at src/opts/bitops.isle line 142.
                                                                                                                                                                                                                                                                                                            returns.extend(Some(v430));
                                                                                                                                                                                                                                                                                                            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 v102,
                                                                    args: ref v103,
                                                                } = &v19.1 {
                                                                    if let &Opcode::Bor = v102 {
                                                                        let v104 = C::unpack_value_array_2(ctx, v103);
                                                                        let mut v107 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v104.0, &mut v107);
                                                                        let mut v107 = v107.into_context_iter();
                                                                        while let Some(v108) = v107.next(ctx) {
                                                                            if v108.0 == I64 {
                                                                                if let &InstructionData::Binary {
                                                                                    opcode: ref v342,
                                                                                    args: ref v343,
                                                                                } = &v108.1 {
                                                                                    if let &Opcode::Bor = v342 {
                                                                                        let mut v114 = C::inst_data_value_etor_returns::default();
                                                                                        C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                                                        let mut v114 = v114.into_context_iter();
                                                                                        while let Some(v115) = v114.next(ctx) {
                                                                                            if v115.0 == I64 {
                                                                                                if let &InstructionData::Binary {
                                                                                                    opcode: ref v354,
                                                                                                    args: ref v355,
                                                                                                } = &v115.1 {
                                                                                                    if let &Opcode::Bor = v354 {
                                                                                                        let v344 = C::unpack_value_array_2(ctx, v343);
                                                                                                        let mut v347 = C::inst_data_value_etor_returns::default();
                                                                                                        C::inst_data_value_etor(ctx, v344.1, &mut v347);
                                                                                                        let mut v347 = v347.into_context_iter();
                                                                                                        while let Some(v348) = v347.next(ctx) {
                                                                                                            if v348.0 == I64 {
                                                                                                                if let &InstructionData::Binary {
                                                                                                                    opcode: ref v447,
                                                                                                                    args: ref v448,
                                                                                                                } = &v348.1 {
                                                                                                                    if let &Opcode::Ishl = v447 {
                                                                                                                        let v356 = C::unpack_value_array_2(ctx, v355);
                                                                                                                        let mut v359 = C::inst_data_value_etor_returns::default();
                                                                                                                        C::inst_data_value_etor(ctx, v356.0, &mut v359);
                                                                                                                        let mut v359 = v359.into_context_iter();
                                                                                                                        while let Some(v360) = v359.next(ctx) {
                                                                                                                            if v360.0 == I64 {
                                                                                                                                if let &InstructionData::Binary {
                                                                                                                                    opcode: ref v363,
                                                                                                                                    args: ref v364,
                                                                                                                                } = &v360.1 {
                                                                                                                                    if let &Opcode::Ishl = v363 {
                                                                                                                                        let v365 = C::unpack_value_array_2(ctx, v364);
                                                                                                                                        let mut v368 = C::inst_data_value_etor_returns::default();
                                                                                                                                        C::inst_data_value_etor(ctx, v365.1, &mut v368);
                                                                                                                                        let mut v368 = v368.into_context_iter();
                                                                                                                                        while let Some(v369) = v368.next(ctx) {
                                                                                                                                            if v369.0 == I64 {
                                                                                                                                                if let &InstructionData::UnaryImm {
                                                                                                                                                    opcode: ref v372,
                                                                                                                                                    imm: v373,
                                                                                                                                                } = &v369.1 {
                                                                                                                                                    if let &Opcode::Iconst = v372 {
                                                                                                                                                        let v374 = C::u64_from_imm64(ctx, v373);
                                                                                                                                                        if v374 == 0x18_u64 {
                                                                                                                                                            let mut v375 = C::inst_data_value_etor_returns::default();
                                                                                                                                                            C::inst_data_value_etor(ctx, v356.1, &mut v375);
                                                                                                                                                            let mut v375 = v375.into_context_iter();
                                                                                                                                                            while let Some(v376) = v375.next(ctx) {
                                                                                                                                                                if v376.0 == I64 {
                                                                                                                                                                    if let &InstructionData::Binary {
                                                                                                                                                                        opcode: ref v491,
                                                                                                                                                                        args: ref v492,
                                                                                                                                                                    } = &v376.1 {
                                                                                                                                                                        if let &Opcode::Ishl = v491 {
                                                                                                                                                                            let v140 = C::unpack_value_array_2(ctx, v139);
                                                                                                                                                                            let mut v382 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                            C::inst_data_value_etor(ctx, v140.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::Bor = v386 {
                                                                                                                                                                                            let v388 = C::unpack_value_array_2(ctx, v387);
                                                                                                                                                                                            let mut v391 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                            C::inst_data_value_etor(ctx, v388.0, &mut v391);
                                                                                                                                                                                            let mut v391 = v391.into_context_iter();
                                                                                                                                                                                            while let Some(v392) = v391.next(ctx) {
                                                                                                                                                                                                if v392.0 == I64 {
                                                                                                                                                                                                    if let &InstructionData::Binary {
                                                                                                                                                                                                        opcode: ref v395,
                                                                                                                                                                                                        args: ref v396,
                                                                                                                                                                                                    } = &v392.1 {
                                                                                                                                                                                                        if let &Opcode::Band = v395 {
                                                                                                                                                                                                            let v397 = C::unpack_value_array_2(ctx, v396);
                                                                                                                                                                                                            let mut v400 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                            C::inst_data_value_etor(ctx, v397.1, &mut v400);
                                                                                                                                                                                                            let mut v400 = v400.into_context_iter();
                                                                                                                                                                                                            while let Some(v401) = v400.next(ctx) {
                                                                                                                                                                                                                if v401.0 == I64 {
                                                                                                                                                                                                                    if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                        opcode: ref v404,
                                                                                                                                                                                                                        imm: v405,
                                                                                                                                                                                                                    } = &v401.1 {
                                                                                                                                                                                                                        if let &Opcode::Iconst = v404 {
                                                                                                                                                                                                                            let v406 = C::u64_from_imm64(ctx, v405);
                                                                                                                                                                                                                            if v406 == 0xff000000_u64 {
                                                                                                                                                                                                                                let mut v407 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                C::inst_data_value_etor(ctx, v388.1, &mut v407);
                                                                                                                                                                                                                                let mut v407 = v407.into_context_iter();
                                                                                                                                                                                                                                while let Some(v408) = v407.next(ctx) {
                                                                                                                                                                                                                                    if v408.0 == I64 {
                                                                                                                                                                                                                                        if let &InstructionData::Binary {
                                                                                                                                                                                                                                            opcode: ref v535,
                                                                                                                                                                                                                                            args: ref v536,
                                                                                                                                                                                                                                        } = &v408.1 {
                                                                                                                                                                                                                                            if let &Opcode::Band = v535 {
                                                                                                                                                                                                                                                let mut v414 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                C::inst_data_value_etor(ctx, v140.1, &mut v414);
                                                                                                                                                                                                                                                let mut v414 = v414.into_context_iter();
                                                                                                                                                                                                                                                while let Some(v415) = v414.next(ctx) {
                                                                                                                                                                                                                                                    if v415.0 == I64 {
                                                                                                                                                                                                                                                        if let &InstructionData::Binary {
                                                                                                                                                                                                                                                            opcode: ref v418,
                                                                                                                                                                                                                                                            args: ref v419,
                                                                                                                                                                                                                                                        } = &v415.1 {
                                                                                                                                                                                                                                                            if let &Opcode::Bor = v418 {
                                                                                                                                                                                                                                                                let v420 = C::unpack_value_array_2(ctx, v419);
                                                                                                                                                                                                                                                                let mut v423 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                C::inst_data_value_etor(ctx, v420.1, &mut v423);
                                                                                                                                                                                                                                                                let mut v423 = v423.into_context_iter();
                                                                                                                                                                                                                                                                while let Some(v424) = v423.next(ctx) {
                                                                                                                                                                                                                                                                    if v424.0 == I64 {
                                                                                                                                                                                                                                                                        if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                            opcode: ref v595,
                                                                                                                                                                                                                                                                            args: ref v596,
                                                                                                                                                                                                                                                                        } = &v424.1 {
                                                                                                                                                                                                                                                                            if let &Opcode::Ushr = v595 {
                                                                                                                                                                                                                                                                                let mut v431 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                C::inst_data_value_etor(ctx, v344.0, &mut v431);
                                                                                                                                                                                                                                                                                let mut v431 = v431.into_context_iter();
                                                                                                                                                                                                                                                                                while let Some(v432) = v431.next(ctx) {
                                                                                                                                                                                                                                                                                    if v432.0 == I64 {
                                                                                                                                                                                                                                                                                        if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                                            opcode: ref v435,
                                                                                                                                                                                                                                                                                            args: ref v436,
                                                                                                                                                                                                                                                                                        } = &v432.1 {
                                                                                                                                                                                                                                                                                            if let &Opcode::Ishl = v435 {
                                                                                                                                                                                                                                                                                                let v437 = C::unpack_value_array_2(ctx, v436);
                                                                                                                                                                                                                                                                                                let v597 = C::unpack_value_array_2(ctx, v596);
                                                                                                                                                                                                                                                                                                if v437.0 == v597.0 {
                                                                                                                                                                                                                                                                                                    let mut v440 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                    C::inst_data_value_etor(ctx, v437.1, &mut v440);
                                                                                                                                                                                                                                                                                                    let mut v440 = v440.into_context_iter();
                                                                                                                                                                                                                                                                                                    while let Some(v441) = v440.next(ctx) {
                                                                                                                                                                                                                                                                                                        if v441.0 == I64 {
                                                                                                                                                                                                                                                                                                            if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                opcode: ref v444,
                                                                                                                                                                                                                                                                                                                imm: v445,
                                                                                                                                                                                                                                                                                                            } = &v441.1 {
                                                                                                                                                                                                                                                                                                                if let &Opcode::Iconst = v444 {
                                                                                                                                                                                                                                                                                                                    let v446 = C::u64_from_imm64(ctx, v445);
                                                                                                                                                                                                                                                                                                                    if v446 == 0x38_u64 {
                                                                                                                                                                                                                                                                                                                        let v449 = C::unpack_value_array_2(ctx, v448);
                                                                                                                                                                                                                                                                                                                        let mut v452 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                        C::inst_data_value_etor(ctx, v449.0, &mut v452);
                                                                                                                                                                                                                                                                                                                        let mut v452 = v452.into_context_iter();
                                                                                                                                                                                                                                                                                                                        while let Some(v453) = v452.next(ctx) {
                                                                                                                                                                                                                                                                                                                            if v453.0 == I64 {
                                                                                                                                                                                                                                                                                                                                if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                                                                                    opcode: ref v456,
                                                                                                                                                                                                                                                                                                                                    args: ref v457,
                                                                                                                                                                                                                                                                                                                                } = &v453.1 {
                                                                                                                                                                                                                                                                                                                                    if let &Opcode::Band = v456 {
                                                                                                                                                                                                                                                                                                                                        let v458 = C::unpack_value_array_2(ctx, v457);
                                                                                                                                                                                                                                                                                                                                        if v437.0 == v458.0 {
                                                                                                                                                                                                                                                                                                                                            let mut v461 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                            C::inst_data_value_etor(ctx, v458.1, &mut v461);
                                                                                                                                                                                                                                                                                                                                            let mut v461 = v461.into_context_iter();
                                                                                                                                                                                                                                                                                                                                            while let Some(v462) = v461.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                if v462.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                    if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                        opcode: ref v465,
                                                                                                                                                                                                                                                                                                                                                        imm: v466,
                                                                                                                                                                                                                                                                                                                                                    } = &v462.1 {
                                                                                                                                                                                                                                                                                                                                                        if let &Opcode::Iconst = v465 {
                                                                                                                                                                                                                                                                                                                                                            let v467 = C::u64_from_imm64(ctx, v466);
                                                                                                                                                                                                                                                                                                                                                            if v467 == 0xff00_u64 {
                                                                                                                                                                                                                                                                                                                                                                let mut v468 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                C::inst_data_value_etor(ctx, v449.1, &mut v468);
                                                                                                                                                                                                                                                                                                                                                                let mut v468 = v468.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                while let Some(v469) = v468.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                    if v469.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                        if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                            opcode: ref v472,
                                                                                                                                                                                                                                                                                                                                                                            imm: v473,
                                                                                                                                                                                                                                                                                                                                                                        } = &v469.1 {
                                                                                                                                                                                                                                                                                                                                                                            if let &Opcode::Iconst = v472 {
                                                                                                                                                                                                                                                                                                                                                                                let v474 = C::u64_from_imm64(ctx, v473);
                                                                                                                                                                                                                                                                                                                                                                                if v474 == 0x28_u64 {
                                                                                                                                                                                                                                                                                                                                                                                    let mut v475 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                    C::inst_data_value_etor(ctx, v365.0, &mut v475);
                                                                                                                                                                                                                                                                                                                                                                                    let mut v475 = v475.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                    while let Some(v476) = v475.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                        if v476.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                            if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                                                                                                                                                opcode: ref v479,
                                                                                                                                                                                                                                                                                                                                                                                                args: ref v480,
                                                                                                                                                                                                                                                                                                                                                                                            } = &v476.1 {
                                                                                                                                                                                                                                                                                                                                                                                                if let &Opcode::Band = v479 {
                                                                                                                                                                                                                                                                                                                                                                                                    let v481 = C::unpack_value_array_2(ctx, v480);
                                                                                                                                                                                                                                                                                                                                                                                                    if v437.0 == v481.0 {
                                                                                                                                                                                                                                                                                                                                                                                                        let mut v484 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                        C::inst_data_value_etor(ctx, v481.1, &mut v484);
                                                                                                                                                                                                                                                                                                                                                                                                        let mut v484 = v484.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                        while let Some(v485) = v484.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                            if v485.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                                                                    opcode: ref v488,
                                                                                                                                                                                                                                                                                                                                                                                                                    imm: v489,
                                                                                                                                                                                                                                                                                                                                                                                                                } = &v485.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                    if let &Opcode::Iconst = v488 {
                                                                                                                                                                                                                                                                                                                                                                                                                        let v490 = C::u64_from_imm64(ctx, v489);
                                                                                                                                                                                                                                                                                                                                                                                                                        if v490 == 0xff0000_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                            let v493 = C::unpack_value_array_2(ctx, v492);
                                                                                                                                                                                                                                                                                                                                                                                                                            let mut v496 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                            C::inst_data_value_etor(ctx, v493.0, &mut v496);
                                                                                                                                                                                                                                                                                                                                                                                                                            let mut v496 = v496.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                            while let Some(v497) = v496.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                if v497.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                    if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                                                                                                                                                                                        opcode: ref v500,
                                                                                                                                                                                                                                                                                                                                                                                                                                        args: ref v501,
                                                                                                                                                                                                                                                                                                                                                                                                                                    } = &v497.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                        if let &Opcode::Band = v500 {
                                                                                                                                                                                                                                                                                                                                                                                                                                            let v502 = C::unpack_value_array_2(ctx, v501);
                                                                                                                                                                                                                                                                                                                                                                                                                                            if v437.0 == v502.0 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                let mut v505 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                C::inst_data_value_etor(ctx, v502.1, &mut v505);
                                                                                                                                                                                                                                                                                                                                                                                                                                                let mut v505 = v505.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                while let Some(v506) = v505.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                    if v506.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                        if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                                                                                                            opcode: ref v509,
                                                                                                                                                                                                                                                                                                                                                                                                                                                            imm: v510,
                                                                                                                                                                                                                                                                                                                                                                                                                                                        } = &v506.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                            if let &Opcode::Iconst = v509 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                let v511 = C::u64_from_imm64(ctx, v510);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                if v511 == 0xff000000_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mut v512 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    C::inst_data_value_etor(ctx, v493.1, &mut v512);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mut v512 = v512.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    while let Some(v513) = v512.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if v513.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                opcode: ref v516,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                imm: v517,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } = &v513.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if let &Opcode::Iconst = v516 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let v518 = C::u64_from_imm64(ctx, v517);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if v518 == 0x8_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mut v519 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        C::inst_data_value_etor(ctx, v397.0, &mut v519);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mut v519 = v519.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        while let Some(v520) = v519.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if v520.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opcode: ref v523,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    args: ref v524,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } = &v520.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if let &Opcode::Ushr = v523 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let v525 = C::unpack_value_array_2(ctx, v524);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if v437.0 == v525.0 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mut v528 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            C::inst_data_value_etor(ctx, v525.1, &mut v528);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mut v528 = v528.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            while let Some(v529) = v528.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if v529.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opcode: ref v532,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        imm: v533,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } = &v529.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if let &Opcode::Iconst = v532 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let v534 = C::u64_from_imm64(ctx, v533);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if v534 == 0x8_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let v537 = C::unpack_value_array_2(ctx, v536);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mut v540 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                C::inst_data_value_etor(ctx, v537.0, &mut v540);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mut v540 = v540.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                while let Some(v541) = v540.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if v541.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            opcode: ref v544,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            args: ref v545,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } = &v541.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if let &Opcode::Ushr = v544 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let v546 = C::unpack_value_array_2(ctx, v545);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if v437.0 == v546.0 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mut v549 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    C::inst_data_value_etor(ctx, v546.1, &mut v549);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mut v549 = v549.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    while let Some(v550) = v549.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if v550.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                opcode: ref v553,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                imm: v554,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } = &v550.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if let &Opcode::Iconst = v553 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let v555 = C::u64_from_imm64(ctx, v554);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if v555 == 0x18_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mut v556 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        C::inst_data_value_etor(ctx, v537.1, &mut v556);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mut v556 = v556.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        while let Some(v557) = v556.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if v557.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opcode: ref v560,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    imm: v561,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } = &v557.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if let &Opcode::Iconst = v560 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let v562 = C::u64_from_imm64(ctx, v561);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if v562 == 0xff0000_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mut v563 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            C::inst_data_value_etor(ctx, v420.0, &mut v563);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mut v563 = v563.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            while let Some(v564) = v563.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if v564.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opcode: ref v567,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        args: ref v568,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } = &v564.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if let &Opcode::Band = v567 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let v569 = C::unpack_value_array_2(ctx, v568);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mut v572 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            C::inst_data_value_etor(ctx, v569.0, &mut v572);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mut v572 = v572.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            while let Some(v573) = v572.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if v573.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opcode: ref v576,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        args: ref v577,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } = &v573.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if let &Opcode::Ushr = v576 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let v578 = C::unpack_value_array_2(ctx, v577);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if v437.0 == v578.0 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mut v581 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                C::inst_data_value_etor(ctx, v578.1, &mut v581);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mut v581 = v581.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                while let Some(v582) = v581.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if v582.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            opcode: ref v585,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            imm: v586,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } = &v582.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if let &Opcode::Iconst = v585 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let v587 = C::u64_from_imm64(ctx, v586);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if v587 == 0x28_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mut v588 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    C::inst_data_value_etor(ctx, v569.1, &mut v588);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mut v588 = v588.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    while let Some(v589) = v588.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if v589.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                opcode: ref v592,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                imm: v593,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } = &v589.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if let &Opcode::Iconst = v592 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let v594 = C::u64_from_imm64(ctx, v593);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if v594 == 0xff00_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mut v600 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        C::inst_data_value_etor(ctx, v597.1, &mut v600);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mut v600 = v600.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        while let Some(v601) = v600.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if v601.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opcode: ref v604,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    imm: v605,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } = &v601.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if let &Opcode::Iconst = v604 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let v606 = C::u64_from_imm64(ctx, v605);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if v606 == 0x38_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let v607 = constructor_bswap(ctx, v2.0, v437.0);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            // Rule at src/opts/bitops.isle line 155.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            returns.extend(Some(v607));
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            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) {
                                                    match &v19.1 {
                                                        &InstructionData::Binary {
                                                            opcode: ref v102,
                                                            args: ref v103,
                                                        } => {
                                                            match v102 {
                                                                &Opcode::Bor => {
                                                                    if v2.0 == v19.0 {
                                                                        let v104 = C::unpack_value_array_2(ctx, v103);
                                                                        let v140 = C::unpack_value_array_2(ctx, v139);
                                                                        if v104.0 == v140.0 {
                                                                            if v104.1 == v140.1 {
                                                                                let v245 = constructor_bor(ctx, v2.0, v104.0, v104.1);
                                                                                // Rule at src/opts/bitops.isle line 578.
                                                                                returns.extend(Some(v245));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                let v246 = constructor_bor(ctx, v2.0, v104.1, v104.0);
                                                                                // Rule at src/opts/bitops.isle line 584.
                                                                                returns.extend(Some(v246));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                            let v246 = constructor_bor(ctx, v2.0, v104.1, v104.0);
                                                                            let v778 = constructor_bor(ctx, v2.0, v246, v140.1);
                                                                            // Rule at src/opts/bitops.isle line 417.
                                                                            returns.extend(Some(v778));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            let v245 = constructor_bor(ctx, v2.0, v104.0, v104.1);
                                                                            let v776 = constructor_bor(ctx, v2.0, v245, v140.1);
                                                                            // Rule at src/opts/bitops.isle line 444.
                                                                            returns.extend(Some(v776));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v104.0 == v140.1 {
                                                                            if v104.1 == v140.0 {
                                                                                let v245 = constructor_bor(ctx, v2.0, v104.0, v104.1);
                                                                                // Rule at src/opts/bitops.isle line 580.
                                                                                returns.extend(Some(v245));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                let v246 = constructor_bor(ctx, v2.0, v104.1, v104.0);
                                                                                // Rule at src/opts/bitops.isle line 582.
                                                                                returns.extend(Some(v246));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                            let v246 = constructor_bor(ctx, v2.0, v104.1, v104.0);
                                                                            let v782 = constructor_bor(ctx, v2.0, v246, v140.0);
                                                                            // Rule at src/opts/bitops.isle line 421.
                                                                            returns.extend(Some(v782));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            let v245 = constructor_bor(ctx, v2.0, v104.0, v104.1);
                                                                            let v780 = constructor_bor(ctx, v2.0, v245, v140.0);
                                                                            // Rule at src/opts/bitops.isle line 446.
                                                                            returns.extend(Some(v780));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v104.1 == v140.0 {
                                                                            let v245 = constructor_bor(ctx, v2.0, v104.0, v104.1);
                                                                            let v776 = constructor_bor(ctx, v2.0, v245, v140.1);
                                                                            // Rule at src/opts/bitops.isle line 415.
                                                                            returns.extend(Some(v776));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            let v246 = constructor_bor(ctx, v2.0, v104.1, v104.0);
                                                                            let v778 = constructor_bor(ctx, v2.0, v246, v140.1);
                                                                            // Rule at src/opts/bitops.isle line 448.
                                                                            returns.extend(Some(v778));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v104.1 == v140.1 {
                                                                            let v245 = constructor_bor(ctx, v2.0, v104.0, v104.1);
                                                                            let v780 = constructor_bor(ctx, v2.0, v245, v140.0);
                                                                            // Rule at src/opts/bitops.isle line 419.
                                                                            returns.extend(Some(v780));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            let v246 = constructor_bor(ctx, v2.0, v104.1, v104.0);
                                                                            let v782 = constructor_bor(ctx, v2.0, v246, v140.0);
                                                                            // Rule at src/opts/bitops.isle line 450.
                                                                            returns.extend(Some(v782));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Bxor => {
                                                                    if v2.0 == v19.0 {
                                                                        let v104 = C::unpack_value_array_2(ctx, v103);
                                                                        let mut v107 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v104.0, &mut v107);
                                                                        let mut v107 = v107.into_context_iter();
                                                                        while let Some(v108) = v107.next(ctx) {
                                                                            if let &InstructionData::Binary {
                                                                                opcode: ref v342,
                                                                                args: ref v343,
                                                                            } = &v108.1 {
                                                                                if let &Opcode::Bxor = v342 {
                                                                                    if v2.0 == v108.0 {
                                                                                        let v140 = C::unpack_value_array_2(ctx, v139);
                                                                                        let v344 = C::unpack_value_array_2(ctx, v343);
                                                                                        if v140.0 == v344.0 {
                                                                                            if v140.1 == v344.1 {
                                                                                                let v761 = constructor_bxor(ctx, v2.0, v344.0, v344.1);
                                                                                                let v762 = constructor_bor(ctx, v2.0, v761, v104.1);
                                                                                                // Rule at src/opts/bitops.isle line 384.
                                                                                                returns.extend(Some(v762));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v766 = constructor_bxor(ctx, v2.0, v344.1, v344.0);
                                                                                                let v767 = constructor_bor(ctx, v2.0, v766, v104.1);
                                                                                                // Rule at src/opts/bitops.isle line 399.
                                                                                                returns.extend(Some(v767));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                        if v140.0 == v344.1 {
                                                                                            if v140.1 == v344.0 {
                                                                                                let v766 = constructor_bxor(ctx, v2.0, v344.1, v344.0);
                                                                                                let v767 = constructor_bor(ctx, v2.0, v766, v104.1);
                                                                                                // Rule at src/opts/bitops.isle line 389.
                                                                                                returns.extend(Some(v767));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v761 = constructor_bxor(ctx, v2.0, v344.0, v344.1);
                                                                                                let v762 = constructor_bor(ctx, v2.0, v761, v104.1);
                                                                                                // Rule at src/opts/bitops.isle line 394.
                                                                                                returns.extend(Some(v762));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let mut v114 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                                        let mut v114 = v114.into_context_iter();
                                                                        while let Some(v115) = v114.next(ctx) {
                                                                            if let &InstructionData::Binary {
                                                                                opcode: ref v354,
                                                                                args: ref v355,
                                                                            } = &v115.1 {
                                                                                if let &Opcode::Bxor = v354 {
                                                                                    if v2.0 == v115.0 {
                                                                                        let v140 = C::unpack_value_array_2(ctx, v139);
                                                                                        let v356 = C::unpack_value_array_2(ctx, v355);
                                                                                        if v140.0 == v356.0 {
                                                                                            if v140.1 == v356.1 {
                                                                                                let v764 = constructor_bxor(ctx, v2.0, v356.0, v356.1);
                                                                                                let v765 = constructor_bor(ctx, v2.0, v764, v104.0);
                                                                                                // Rule at src/opts/bitops.isle line 386.
                                                                                                returns.extend(Some(v765));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v768 = constructor_bxor(ctx, v2.0, v356.1, v356.0);
                                                                                                let v769 = constructor_bor(ctx, v2.0, v768, v104.0);
                                                                                                // Rule at src/opts/bitops.isle line 401.
                                                                                                returns.extend(Some(v769));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                        if v140.0 == v356.1 {
                                                                                            if v140.1 == v356.0 {
                                                                                                let v768 = constructor_bxor(ctx, v2.0, v356.1, v356.0);
                                                                                                let v769 = constructor_bor(ctx, v2.0, v768, v104.0);
                                                                                                // Rule at src/opts/bitops.isle line 391.
                                                                                                returns.extend(Some(v769));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v764 = constructor_bxor(ctx, v2.0, v356.0, v356.1);
                                                                                                let v765 = constructor_bor(ctx, v2.0, v764, v104.0);
                                                                                                // Rule at src/opts/bitops.isle line 396.
                                                                                                returns.extend(Some(v765));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let v140 = C::unpack_value_array_2(ctx, v139);
                                                                        let mut v382 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v140.0, &mut v382);
                                                                        let mut v382 = v382.into_context_iter();
                                                                        while let Some(v383) = v382.next(ctx) {
                                                                            if let &InstructionData::Binary {
                                                                                opcode: ref v386,
                                                                                args: ref v387,
                                                                            } = &v383.1 {
                                                                                if let &Opcode::Bxor = v386 {
                                                                                    if v2.0 == v383.0 {
                                                                                        let v388 = C::unpack_value_array_2(ctx, v387);
                                                                                        if v104.0 == v388.0 {
                                                                                            if v104.1 == v388.1 {
                                                                                                let v243 = constructor_bxor(ctx, v2.0, v104.0, v104.1);
                                                                                                let v760 = constructor_bor(ctx, v2.0, v243, v140.1);
                                                                                                // Rule at src/opts/bitops.isle line 383.
                                                                                                returns.extend(Some(v760));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v244 = constructor_bxor(ctx, v2.0, v104.1, v104.0);
                                                                                                let v770 = constructor_bor(ctx, v2.0, v244, v140.1);
                                                                                                // Rule at src/opts/bitops.isle line 398.
                                                                                                returns.extend(Some(v770));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                        if v104.1 == v388.0 {
                                                                                            if v104.0 == v388.1 {
                                                                                                let v243 = constructor_bxor(ctx, v2.0, v104.0, v104.1);
                                                                                                let v760 = constructor_bor(ctx, v2.0, v243, v140.1);
                                                                                                // Rule at src/opts/bitops.isle line 388.
                                                                                                returns.extend(Some(v760));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v244 = constructor_bxor(ctx, v2.0, v104.1, v104.0);
                                                                                                let v770 = constructor_bor(ctx, v2.0, v244, v140.1);
                                                                                                // Rule at src/opts/bitops.isle line 393.
                                                                                                returns.extend(Some(v770));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let mut v414 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v140.1, &mut v414);
                                                                        let mut v414 = v414.into_context_iter();
                                                                        while let Some(v415) = v414.next(ctx) {
                                                                            if let &InstructionData::Binary {
                                                                                opcode: ref v418,
                                                                                args: ref v419,
                                                                            } = &v415.1 {
                                                                                if let &Opcode::Bxor = v418 {
                                                                                    if v2.0 == v415.0 {
                                                                                        let v420 = C::unpack_value_array_2(ctx, v419);
                                                                                        if v104.0 == v420.0 {
                                                                                            if v104.1 == v420.1 {
                                                                                                let v243 = constructor_bxor(ctx, v2.0, v104.0, v104.1);
                                                                                                let v763 = constructor_bor(ctx, v2.0, v243, v140.0);
                                                                                                // Rule at src/opts/bitops.isle line 385.
                                                                                                returns.extend(Some(v763));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v244 = constructor_bxor(ctx, v2.0, v104.1, v104.0);
                                                                                                let v771 = constructor_bor(ctx, v2.0, v244, v140.0);
                                                                                                // Rule at src/opts/bitops.isle line 400.
                                                                                                returns.extend(Some(v771));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                        if v104.1 == v420.0 {
                                                                                            if v104.0 == v420.1 {
                                                                                                let v243 = constructor_bxor(ctx, v2.0, v104.0, v104.1);
                                                                                                let v763 = constructor_bor(ctx, v2.0, v243, v140.0);
                                                                                                // Rule at src/opts/bitops.isle line 390.
                                                                                                returns.extend(Some(v763));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v244 = constructor_bxor(ctx, v2.0, v104.1, v104.0);
                                                                                                let v771 = constructor_bor(ctx, v2.0, v244, v140.0);
                                                                                                // Rule at src/opts/bitops.isle line 395.
                                                                                                returns.extend(Some(v771));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v29,
                                                            arg: v30,
                                                        } => {
                                                            if let &Opcode::Bnot = v29 {
                                                                if v2.0 == v19.0 {
                                                                    let v140 = C::unpack_value_array_2(ctx, v139);
                                                                    if v30 == v140.0 {
                                                                        let v815 = constructor_band(ctx, v2.0, v140.1, v30);
                                                                        let v816 = constructor_bnot(ctx, v2.0, v815);
                                                                        // Rule at src/opts/bitops.isle line 487.
                                                                        returns.extend(Some(v816));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v30 == v140.1 {
                                                                        let v812 = constructor_band(ctx, v2.0, v140.0, v30);
                                                                        let v813 = constructor_bnot(ctx, v2.0, v812);
                                                                        // Rule at src/opts/bitops.isle line 485.
                                                                        returns.extend(Some(v813));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let v140 = C::unpack_value_array_2(ctx, v139);
                                                let mut v382 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v140.0, &mut v382);
                                                let mut v382 = v382.into_context_iter();
                                                while let Some(v383) = v382.next(ctx) {
                                                    match &v383.1 {
                                                        &InstructionData::Binary {
                                                            opcode: ref v386,
                                                            args: ref v387,
                                                        } => {
                                                            match v386 {
                                                                &Opcode::Band => {
                                                                    if v2.0 == v383.0 {
                                                                        let v388 = C::unpack_value_array_2(ctx, v387);
                                                                        if v7.0 == v388.0 {
                                                                            let v849 = constructor_bor(ctx, v2.0, v140.1, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 519.
                                                                            returns.extend(Some(v849));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.0 == v388.1 {
                                                                            let v849 = constructor_bor(ctx, v2.0, v140.1, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 523.
                                                                            returns.extend(Some(v849));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Bxor => {
                                                                    if v2.0 == v383.0 {
                                                                        let v388 = C::unpack_value_array_2(ctx, v387);
                                                                        if v7.0 == v388.0 {
                                                                            let v697 = constructor_bxor(ctx, v2.0, v388.1, v140.1);
                                                                            let v698 = constructor_bor(ctx, v2.0, v697, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 294.
                                                                            returns.extend(Some(v698));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.0 == v388.1 {
                                                                            let v705 = constructor_bxor(ctx, v2.0, v388.0, v140.1);
                                                                            let v706 = constructor_bor(ctx, v2.0, v705, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 298.
                                                                            returns.extend(Some(v706));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v616,
                                                            arg: v617,
                                                        } => {
                                                            if let &Opcode::Bnot = v616 {
                                                                if v7.0 == v617 {
                                                                    if v2.0 == v383.0 {
                                                                        let v731 = constructor_bnot(ctx, v2.0, v140.1);
                                                                        let v857 = constructor_bor(ctx, v2.0, v7.0, v731);
                                                                        // Rule at src/opts/bitops.isle line 560.
                                                                        returns.extend(Some(v857));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let mut v414 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v140.1, &mut v414);
                                                let mut v414 = v414.into_context_iter();
                                                while let Some(v415) = v414.next(ctx) {
                                                    match &v415.1 {
                                                        &InstructionData::Binary {
                                                            opcode: ref v418,
                                                            args: ref v419,
                                                        } => {
                                                            match v418 {
                                                                &Opcode::Band => {
                                                                    if v2.0 == v415.0 {
                                                                        let v420 = C::unpack_value_array_2(ctx, v419);
                                                                        if v7.0 == v420.0 {
                                                                            let v308 = constructor_bor(ctx, v2.0, v140.0, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 517.
                                                                            returns.extend(Some(v308));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.0 == v420.1 {
                                                                            let v308 = constructor_bor(ctx, v2.0, v140.0, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 521.
                                                                            returns.extend(Some(v308));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Bxor => {
                                                                    if v2.0 == v415.0 {
                                                                        let v420 = C::unpack_value_array_2(ctx, v419);
                                                                        if v7.0 == v420.0 {
                                                                            let v701 = constructor_bxor(ctx, v2.0, v420.1, v140.0);
                                                                            let v702 = constructor_bor(ctx, v2.0, v701, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 296.
                                                                            returns.extend(Some(v702));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.0 == v420.1 {
                                                                            let v709 = constructor_bxor(ctx, v2.0, v420.0, v140.0);
                                                                            let v710 = constructor_bor(ctx, v2.0, v709, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 300.
                                                                            returns.extend(Some(v710));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v613,
                                                            arg: v614,
                                                        } => {
                                                            if let &Opcode::Bnot = v613 {
                                                                if v7.0 == v614 {
                                                                    if v2.0 == v415.0 {
                                                                        let v734 = constructor_bnot(ctx, v2.0, v140.0);
                                                                        let v859 = constructor_bor(ctx, v2.0, v7.0, v734);
                                                                        // Rule at src/opts/bitops.isle line 562.
                                                                        returns.extend(Some(v859));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                if v7.0 == v140.0 {
                                                    let v608 = constructor_bor(ctx, v2.0, v7.0, v140.1);
                                                    // Rule at src/opts/bitops.isle line 404.
                                                    returns.extend(Some(v608));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.0 == v140.1 {
                                                    let v772 = constructor_bor(ctx, v2.0, v7.0, v140.0);
                                                    // Rule at src/opts/bitops.isle line 406.
                                                    returns.extend(Some(v772));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        &Opcode::Ishl => {
                                            let v297 = C::ty_int(ctx, v2.0);
                                            if let Some(v298) = v297 {
                                                if v11.0 == v298 {
                                                    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 v102,
                                                            args: ref v103,
                                                        } = &v19.1 {
                                                            if let &Opcode::Ushr = v102 {
                                                                if v11.0 == v19.0 {
                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let v140 = C::unpack_value_array_2(ctx, v139);
                                                                    if v104.0 == v140.0 {
                                                                        let mut v114 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                                        let mut v114 = v114.into_context_iter();
                                                                        while let Some(v115) = v114.next(ctx) {
                                                                            if let &InstructionData::UnaryImm {
                                                                                opcode: ref v132,
                                                                                imm: v133,
                                                                            } = &v115.1 {
                                                                                if let &Opcode::Iconst = v132 {
                                                                                    let mut v414 = C::inst_data_value_etor_returns::default();
                                                                                    C::inst_data_value_etor(ctx, v140.1, &mut v414);
                                                                                    let mut v414 = v414.into_context_iter();
                                                                                    while let Some(v415) = v414.next(ctx) {
                                                                                        if let &InstructionData::UnaryImm {
                                                                                            opcode: ref v1097,
                                                                                            imm: v1098,
                                                                                        } = &v415.1 {
                                                                                            if let &Opcode::Iconst = v1097 {
                                                                                                let v309 = C::u64_from_imm64(ctx, v133);
                                                                                                let v1856 = C::lane_type(ctx, v298);
                                                                                                let v1857 = C::ty_bits_u64(ctx, v1856);
                                                                                                let v1367 = C::u64_from_imm64(ctx, v1098);
                                                                                                let v1861 = C::u64_wrapping_sub(ctx, v1857, v1367);
                                                                                                let v1862 = C::u64_eq(ctx, v309, v1861);
                                                                                                if v1862 == true {
                                                                                                    let v1863 = constructor_rotl(ctx, v298, v104.0, v140.1);
                                                                                                    // Rule at src/opts/shifts.isle line 284.
                                                                                                    returns.extend(Some(v1863));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Ushr => {
                                            let v297 = C::ty_int(ctx, v2.0);
                                            if let Some(v298) = v297 {
                                                if v11.0 == v298 {
                                                    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 v102,
                                                            args: ref v103,
                                                        } = &v19.1 {
                                                            if let &Opcode::Ishl = v102 {
                                                                if v11.0 == v19.0 {
                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let v140 = C::unpack_value_array_2(ctx, v139);
                                                                    if v104.0 == v140.0 {
                                                                        let mut v114 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                                        let mut v114 = v114.into_context_iter();
                                                                        while let Some(v115) = v114.next(ctx) {
                                                                            if let &InstructionData::UnaryImm {
                                                                                opcode: ref v132,
                                                                                imm: v133,
                                                                            } = &v115.1 {
                                                                                if let &Opcode::Iconst = v132 {
                                                                                    let mut v414 = C::inst_data_value_etor_returns::default();
                                                                                    C::inst_data_value_etor(ctx, v140.1, &mut v414);
                                                                                    let mut v414 = v414.into_context_iter();
                                                                                    while let Some(v415) = v414.next(ctx) {
                                                                                        if let &InstructionData::UnaryImm {
                                                                                            opcode: ref v1097,
                                                                                            imm: v1098,
                                                                                        } = &v415.1 {
                                                                                            if let &Opcode::Iconst = v1097 {
                                                                                                let v1367 = C::u64_from_imm64(ctx, v1098);
                                                                                                let v1856 = C::lane_type(ctx, v298);
                                                                                                let v1857 = C::ty_bits_u64(ctx, v1856);
                                                                                                let v309 = C::u64_from_imm64(ctx, v133);
                                                                                                let v1858 = C::u64_wrapping_sub(ctx, v1857, v309);
                                                                                                let v1859 = C::u64_eq(ctx, v1367, v1858);
                                                                                                if v1859 == true {
                                                                                                    let v1860 = constructor_rotl(ctx, v298, v104.0, v104.1);
                                                                                                    // Rule at src/opts/shifts.isle line 279.
                                                                                                    returns.extend(Some(v1860));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::IntCompare {
                                    opcode: ref v742,
                                    args: ref v743,
                                    cond: ref v744,
                                } => {
                                    if let &Opcode::Icmp = v742 {
                                        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 v736,
                                                args: ref v737,
                                                cond: ref v738,
                                            } = &v19.1 {
                                                if let &Opcode::Icmp = v736 {
                                                    if v11.0 == v19.0 {
                                                        match v738 {
                                                            &IntCC::Equal => {
                                                                match v744 {
                                                                    &IntCC::SignedGreaterThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v739 = C::unpack_value_array_2(ctx, v737);
                                                                            let v745 = C::unpack_value_array_2(ctx, v743);
                                                                            if v739.0 == v745.0 {
                                                                                if v739.1 == v745.1 {
                                                                                    let v759 = constructor_sle(ctx, v2.0, v739.1, v739.0);
                                                                                    // Rule at src/opts/bitops.isle line 380.
                                                                                    returns.extend(Some(v759));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                            if v739.0 == v745.1 {
                                                                                if v739.1 == v745.0 {
                                                                                    let v758 = constructor_sle(ctx, v2.0, v739.0, v739.1);
                                                                                    // Rule at src/opts/bitops.isle line 378.
                                                                                    returns.extend(Some(v758));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedLessThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v739 = C::unpack_value_array_2(ctx, v737);
                                                                            let v745 = C::unpack_value_array_2(ctx, v743);
                                                                            if v739.0 == v745.0 {
                                                                                if v739.1 == v745.1 {
                                                                                    let v758 = constructor_sle(ctx, v2.0, v739.0, v739.1);
                                                                                    // Rule at src/opts/bitops.isle line 372.
                                                                                    returns.extend(Some(v758));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                            if v739.0 == v745.1 {
                                                                                if v739.1 == v745.0 {
                                                                                    let v759 = constructor_sle(ctx, v2.0, v739.1, v739.0);
                                                                                    // Rule at src/opts/bitops.isle line 374.
                                                                                    returns.extend(Some(v759));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedGreaterThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v739 = C::unpack_value_array_2(ctx, v737);
                                                                            let v745 = C::unpack_value_array_2(ctx, v743);
                                                                            if v739.0 == v745.0 {
                                                                                if v739.1 == v745.1 {
                                                                                    let v757 = constructor_ule(ctx, v2.0, v739.1, v739.0);
                                                                                    // Rule at src/opts/bitops.isle line 368.
                                                                                    returns.extend(Some(v757));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                            if v739.0 == v745.1 {
                                                                                if v739.1 == v745.0 {
                                                                                    let v756 = constructor_ule(ctx, v2.0, v739.0, v739.1);
                                                                                    // Rule at src/opts/bitops.isle line 366.
                                                                                    returns.extend(Some(v756));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v739 = C::unpack_value_array_2(ctx, v737);
                                                                            let v745 = C::unpack_value_array_2(ctx, v743);
                                                                            if v739.0 == v745.0 {
                                                                                if v739.1 == v745.1 {
                                                                                    let v756 = constructor_ule(ctx, v2.0, v739.0, v739.1);
                                                                                    // Rule at src/opts/bitops.isle line 360.
                                                                                    returns.extend(Some(v756));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                            if v739.0 == v745.1 {
                                                                                if v739.1 == v745.0 {
                                                                                    let v757 = constructor_ule(ctx, v2.0, v739.1, v739.0);
                                                                                    // Rule at src/opts/bitops.isle line 362.
                                                                                    returns.extend(Some(v757));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                            &IntCC::SignedGreaterThan => {
                                                                match v744 {
                                                                    &IntCC::Equal => {
                                                                        if v2.0 == v11.0 {
                                                                            let v739 = C::unpack_value_array_2(ctx, v737);
                                                                            let v745 = C::unpack_value_array_2(ctx, v743);
                                                                            if v739.0 == v745.0 {
                                                                                if v739.1 == v745.1 {
                                                                                    let v759 = constructor_sle(ctx, v2.0, v739.1, v739.0);
                                                                                    // Rule at src/opts/bitops.isle line 379.
                                                                                    returns.extend(Some(v759));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                            if v739.0 == v745.1 {
                                                                                if v739.1 == v745.0 {
                                                                                    let v759 = constructor_sle(ctx, v2.0, v739.1, v739.0);
                                                                                    // Rule at src/opts/bitops.isle line 377.
                                                                                    returns.extend(Some(v759));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedGreaterThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v739 = C::unpack_value_array_2(ctx, v737);
                                                                            let v745 = C::unpack_value_array_2(ctx, v743);
                                                                            if v739.0 == v745.1 {
                                                                                if v739.1 == v745.0 {
                                                                                    let v749 = constructor_ne(ctx, v2.0, v739.1, v739.0);
                                                                                    // Rule at src/opts/bitops.isle line 335.
                                                                                    returns.extend(Some(v749));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    let v748 = constructor_ne(ctx, v2.0, v739.0, v739.1);
                                                                                    // Rule at src/opts/bitops.isle line 336.
                                                                                    returns.extend(Some(v748));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedLessThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v739 = C::unpack_value_array_2(ctx, v737);
                                                                            let v745 = C::unpack_value_array_2(ctx, v743);
                                                                            if v739.0 == v745.0 {
                                                                                if v739.1 == v745.1 {
                                                                                    let v748 = constructor_ne(ctx, v2.0, v739.0, v739.1);
                                                                                    // Rule at src/opts/bitops.isle line 332.
                                                                                    returns.extend(Some(v748));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    let v749 = constructor_ne(ctx, v2.0, v739.1, v739.0);
                                                                                    // Rule at src/opts/bitops.isle line 337.
                                                                                    returns.extend(Some(v749));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                            &IntCC::SignedLessThan => {
                                                                match v744 {
                                                                    &IntCC::Equal => {
                                                                        if v2.0 == v11.0 {
                                                                            let v739 = C::unpack_value_array_2(ctx, v737);
                                                                            let v745 = C::unpack_value_array_2(ctx, v743);
                                                                            if v739.0 == v745.0 {
                                                                                if v739.1 == v745.1 {
                                                                                    let v758 = constructor_sle(ctx, v2.0, v739.0, v739.1);
                                                                                    // Rule at src/opts/bitops.isle line 371.
                                                                                    returns.extend(Some(v758));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                            if v739.0 == v745.1 {
                                                                                if v739.1 == v745.0 {
                                                                                    let v758 = constructor_sle(ctx, v2.0, v739.0, v739.1);
                                                                                    // Rule at src/opts/bitops.isle line 373.
                                                                                    returns.extend(Some(v758));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedGreaterThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v739 = C::unpack_value_array_2(ctx, v737);
                                                                            let v745 = C::unpack_value_array_2(ctx, v743);
                                                                            if v739.0 == v745.0 {
                                                                                if v739.1 == v745.1 {
                                                                                    let v748 = constructor_ne(ctx, v2.0, v739.0, v739.1);
                                                                                    // Rule at src/opts/bitops.isle line 331.
                                                                                    returns.extend(Some(v748));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    let v749 = constructor_ne(ctx, v2.0, v739.1, v739.0);
                                                                                    // Rule at src/opts/bitops.isle line 338.
                                                                                    returns.extend(Some(v749));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedLessThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v739 = C::unpack_value_array_2(ctx, v737);
                                                                            let v745 = C::unpack_value_array_2(ctx, v743);
                                                                            if v739.0 == v745.1 {
                                                                                if v739.1 == v745.0 {
                                                                                    let v748 = constructor_ne(ctx, v2.0, v739.0, v739.1);
                                                                                    // Rule at src/opts/bitops.isle line 333.
                                                                                    returns.extend(Some(v748));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    let v749 = constructor_ne(ctx, v2.0, v739.1, v739.0);
                                                                                    // Rule at src/opts/bitops.isle line 334.
                                                                                    returns.extend(Some(v749));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                            &IntCC::UnsignedGreaterThan => {
                                                                match v744 {
                                                                    &IntCC::Equal => {
                                                                        if v2.0 == v11.0 {
                                                                            let v739 = C::unpack_value_array_2(ctx, v737);
                                                                            let v745 = C::unpack_value_array_2(ctx, v743);
                                                                            if v739.0 == v745.0 {
                                                                                if v739.1 == v745.1 {
                                                                                    let v757 = constructor_ule(ctx, v2.0, v739.1, v739.0);
                                                                                    // Rule at src/opts/bitops.isle line 367.
                                                                                    returns.extend(Some(v757));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                            if v739.0 == v745.1 {
                                                                                if v739.1 == v745.0 {
                                                                                    let v757 = constructor_ule(ctx, v2.0, v739.1, v739.0);
                                                                                    // Rule at src/opts/bitops.isle line 365.
                                                                                    returns.extend(Some(v757));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedGreaterThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v739 = C::unpack_value_array_2(ctx, v737);
                                                                            let v745 = C::unpack_value_array_2(ctx, v743);
                                                                            if v739.0 == v745.1 {
                                                                                if v739.1 == v745.0 {
                                                                                    let v749 = constructor_ne(ctx, v2.0, v739.1, v739.0);
                                                                                    // Rule at src/opts/bitops.isle line 345.
                                                                                    returns.extend(Some(v749));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    let v748 = constructor_ne(ctx, v2.0, v739.0, v739.1);
                                                                                    // Rule at src/opts/bitops.isle line 346.
                                                                                    returns.extend(Some(v748));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v739 = C::unpack_value_array_2(ctx, v737);
                                                                            let v745 = C::unpack_value_array_2(ctx, v743);
                                                                            if v739.0 == v745.0 {
                                                                                if v739.1 == v745.1 {
                                                                                    let v748 = constructor_ne(ctx, v2.0, v739.0, v739.1);
                                                                                    // Rule at src/opts/bitops.isle line 342.
                                                                                    returns.extend(Some(v748));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    let v749 = constructor_ne(ctx, v2.0, v739.1, v739.0);
                                                                                    // Rule at src/opts/bitops.isle line 347.
                                                                                    returns.extend(Some(v749));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                            &IntCC::UnsignedLessThan => {
                                                                match v744 {
                                                                    &IntCC::Equal => {
                                                                        if v2.0 == v11.0 {
                                                                            let v739 = C::unpack_value_array_2(ctx, v737);
                                                                            let v745 = C::unpack_value_array_2(ctx, v743);
                                                                            if v739.0 == v745.0 {
                                                                                if v739.1 == v745.1 {
                                                                                    let v756 = constructor_ule(ctx, v2.0, v739.0, v739.1);
                                                                                    // Rule at src/opts/bitops.isle line 359.
                                                                                    returns.extend(Some(v756));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                            if v739.0 == v745.1 {
                                                                                if v739.1 == v745.0 {
                                                                                    let v756 = constructor_ule(ctx, v2.0, v739.0, v739.1);
                                                                                    // Rule at src/opts/bitops.isle line 361.
                                                                                    returns.extend(Some(v756));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedGreaterThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v739 = C::unpack_value_array_2(ctx, v737);
                                                                            let v745 = C::unpack_value_array_2(ctx, v743);
                                                                            if v739.0 == v745.0 {
                                                                                if v739.1 == v745.1 {
                                                                                    let v748 = constructor_ne(ctx, v2.0, v739.0, v739.1);
                                                                                    // Rule at src/opts/bitops.isle line 341.
                                                                                    returns.extend(Some(v748));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    let v749 = constructor_ne(ctx, v2.0, v739.1, v739.0);
                                                                                    // Rule at src/opts/bitops.isle line 348.
                                                                                    returns.extend(Some(v749));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v739 = C::unpack_value_array_2(ctx, v737);
                                                                            let v745 = C::unpack_value_array_2(ctx, v743);
                                                                            if v739.0 == v745.1 {
                                                                                if v739.1 == v745.0 {
                                                                                    let v748 = constructor_ne(ctx, v2.0, v739.0, v739.1);
                                                                                    // Rule at src/opts/bitops.isle line 343.
                                                                                    returns.extend(Some(v748));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    let v749 = constructor_ne(ctx, v2.0, v739.1, v739.0);
                                                                                    // Rule at src/opts/bitops.isle line 344.
                                                                                    returns.extend(Some(v749));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                        let v292 = C::fits_in_64(ctx, v2.0);
                                                        if let Some(v293) = v292 {
                                                            if v11.0 == v293 {
                                                                let v1439 = constructor_intcc_comparable(ctx, v738, v744);
                                                                if let Some(v1440) = v1439 {
                                                                    let v739 = C::unpack_value_array_2(ctx, v737);
                                                                    let v745 = C::unpack_value_array_2(ctx, v743);
                                                                    if v739.0 == v745.0 {
                                                                        if v739.1 == v745.1 {
                                                                            let v1441 = constructor_decompose_intcc(ctx, v738);
                                                                            let v1442 = constructor_decompose_intcc(ctx, v744);
                                                                            let v1445 = C::u64_or(ctx, v1441, v1442);
                                                                            let v1446 = constructor_compose_icmp(ctx, v293, v1445, v1440, v739.0, v739.1);
                                                                            // Rule at src/opts/icmp.isle line 183.
                                                                            returns.extend(Some(v1446));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v26,
                                    arg: v27,
                                } => {
                                    match v26 {
                                        &Opcode::Splat => {
                                            let v1953 = C::ty_vector_not_float(ctx, v2.0);
                                            if let Some(v1954) = v1953 {
                                                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 v1816 = C::lane_type(ctx, v2.0);
                                                                    let v1957 = constructor_bor(ctx, v1816, v30, v27);
                                                                    let v1958 = constructor_splat(ctx, v2.0, v1957);
                                                                    // Rule at src/opts/vector.isle line 18.
                                                                    returns.extend(Some(v1958));
                                                                    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) {
                                                    match &v19.1 {
                                                        &InstructionData::Binary {
                                                            opcode: ref v102,
                                                            args: ref v103,
                                                        } => {
                                                            match v102 {
                                                                &Opcode::Band => {
                                                                    if v2.0 == v19.0 {
                                                                        let mut v626 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v27, &mut v626);
                                                                        let mut v626 = v626.into_context_iter();
                                                                        while let Some(v627) = v626.next(ctx) {
                                                                            if let &InstructionData::Binary {
                                                                                opcode: ref v630,
                                                                                args: ref v631,
                                                                            } = &v627.1 {
                                                                                match v630 {
                                                                                    &Opcode::Bor => {
                                                                                        if v2.0 == v627.0 {
                                                                                            let v104 = C::unpack_value_array_2(ctx, v103);
                                                                                            let v632 = C::unpack_value_array_2(ctx, v631);
                                                                                            if v104.0 == v632.0 {
                                                                                                if v104.1 == v632.1 {
                                                                                                    let v243 = constructor_bxor(ctx, v2.0, v104.0, v104.1);
                                                                                                    let v635 = constructor_bnot(ctx, v2.0, v243);
                                                                                                    // Rule at src/opts/bitops.isle line 635.
                                                                                                    returns.extend(Some(v635));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    let v244 = constructor_bxor(ctx, v2.0, v104.1, v104.0);
                                                                                                    let v649 = constructor_bnot(ctx, v2.0, v244);
                                                                                                    // Rule at src/opts/bitops.isle line 641.
                                                                                                    returns.extend(Some(v649));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                                let mut v114 = C::inst_data_value_etor_returns::default();
                                                                                                C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                                                                let mut v114 = v114.into_context_iter();
                                                                                                while let Some(v115) = v114.next(ctx) {
                                                                                                    if let &InstructionData::Unary {
                                                                                                        opcode: ref v118,
                                                                                                        arg: v119,
                                                                                                    } = &v115.1 {
                                                                                                        if let &Opcode::Bnot = v118 {
                                                                                                            if v119 == v632.1 {
                                                                                                                if v2.0 == v115.0 {
                                                                                                                    let v899 = constructor_bnot(ctx, v2.0, v119);
                                                                                                                    // Rule at src/opts/bitops.isle line 621.
                                                                                                                    returns.extend(Some(v899));
                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                            if v104.0 == v632.1 {
                                                                                                if v104.1 == v632.0 {
                                                                                                    let v243 = constructor_bxor(ctx, v2.0, v104.0, v104.1);
                                                                                                    let v635 = constructor_bnot(ctx, v2.0, v243);
                                                                                                    // Rule at src/opts/bitops.isle line 637.
                                                                                                    returns.extend(Some(v635));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    let v244 = constructor_bxor(ctx, v2.0, v104.1, v104.0);
                                                                                                    let v649 = constructor_bnot(ctx, v2.0, v244);
                                                                                                    // Rule at src/opts/bitops.isle line 639.
                                                                                                    returns.extend(Some(v649));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                                let mut v114 = C::inst_data_value_etor_returns::default();
                                                                                                C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                                                                let mut v114 = v114.into_context_iter();
                                                                                                while let Some(v115) = v114.next(ctx) {
                                                                                                    if let &InstructionData::Unary {
                                                                                                        opcode: ref v118,
                                                                                                        arg: v119,
                                                                                                    } = &v115.1 {
                                                                                                        if let &Opcode::Bnot = v118 {
                                                                                                            if v119 == v632.0 {
                                                                                                                if v2.0 == v115.0 {
                                                                                                                    let v899 = constructor_bnot(ctx, v2.0, v119);
                                                                                                                    // Rule at src/opts/bitops.isle line 619.
                                                                                                                    returns.extend(Some(v899));
                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                            let mut v107 = C::inst_data_value_etor_returns::default();
                                                                                            C::inst_data_value_etor(ctx, v104.0, &mut v107);
                                                                                            let mut v107 = v107.into_context_iter();
                                                                                            while let Some(v108) = v107.next(ctx) {
                                                                                                if let &InstructionData::Unary {
                                                                                                    opcode: ref v111,
                                                                                                    arg: v112,
                                                                                                } = &v108.1 {
                                                                                                    if let &Opcode::Bnot = v111 {
                                                                                                        if v2.0 == v108.0 {
                                                                                                            if v112 == v632.0 {
                                                                                                                if v104.1 == v632.1 {
                                                                                                                    let v898 = constructor_bnot(ctx, v2.0, v112);
                                                                                                                    // Rule at src/opts/bitops.isle line 615.
                                                                                                                    returns.extend(Some(v898));
                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                }
                                                                                                            }
                                                                                                            if v112 == v632.1 {
                                                                                                                if v104.1 == v632.0 {
                                                                                                                    let v898 = constructor_bnot(ctx, v2.0, v112);
                                                                                                                    // Rule at src/opts/bitops.isle line 617.
                                                                                                                    returns.extend(Some(v898));
                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                    &Opcode::Bxor => {
                                                                                        if v2.0 == v627.0 {
                                                                                            let v104 = C::unpack_value_array_2(ctx, v103);
                                                                                            let v632 = C::unpack_value_array_2(ctx, v631);
                                                                                            if v104.0 == v632.0 {
                                                                                                if v104.1 == v632.1 {
                                                                                                    let v243 = constructor_bxor(ctx, v2.0, v104.0, v104.1);
                                                                                                    let v635 = constructor_bnot(ctx, v2.0, v243);
                                                                                                    // Rule at src/opts/bitops.isle line 229.
                                                                                                    returns.extend(Some(v635));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    let v244 = constructor_bxor(ctx, v2.0, v104.1, v104.0);
                                                                                                    let v649 = constructor_bnot(ctx, v2.0, v244);
                                                                                                    // Rule at src/opts/bitops.isle line 235.
                                                                                                    returns.extend(Some(v649));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                            if v104.0 == v632.1 {
                                                                                                if v104.1 == v632.0 {
                                                                                                    let v243 = constructor_bxor(ctx, v2.0, v104.0, v104.1);
                                                                                                    let v635 = constructor_bnot(ctx, v2.0, v243);
                                                                                                    // Rule at src/opts/bitops.isle line 231.
                                                                                                    returns.extend(Some(v635));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    let v244 = constructor_bxor(ctx, v2.0, v104.1, v104.0);
                                                                                                    let v649 = constructor_bnot(ctx, v2.0, v244);
                                                                                                    // Rule at src/opts/bitops.isle line 233.
                                                                                                    returns.extend(Some(v649));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                    _ => {}
                                                                                }
                                                                            }
                                                                        }
                                                                        let v104 = C::unpack_value_array_2(ctx, v103);
                                                                        if v27 == v104.0 {
                                                                            let v620 = constructor_bnot(ctx, v2.0, v104.0);
                                                                            let v621 = constructor_bor(ctx, v2.0, v104.1, v620);
                                                                            // Rule at src/opts/bitops.isle line 220.
                                                                            returns.extend(Some(v621));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v27 == v104.1 {
                                                                            let v307 = constructor_bor(ctx, v2.0, v104.0, v7.1);
                                                                            // Rule at src/opts/bitops.isle line 44.
                                                                            returns.extend(Some(v307));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Bxor => {
                                                                    if v2.0 == v19.0 {
                                                                        let v104 = C::unpack_value_array_2(ctx, v103);
                                                                        if v27 == v104.0 {
                                                                            let v247 = constructor_band(ctx, v2.0, v104.1, v104.0);
                                                                            let v814 = constructor_bnot(ctx, v2.0, v247);
                                                                            // Rule at src/opts/bitops.isle line 486.
                                                                            returns.extend(Some(v814));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v27 == v104.1 {
                                                                            let v143 = constructor_band(ctx, v2.0, v104.0, v104.1);
                                                                            let v811 = constructor_bnot(ctx, v2.0, v143);
                                                                            // Rule at src/opts/bitops.isle line 484.
                                                                            returns.extend(Some(v811));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v29,
                                                            arg: v30,
                                                        } => {
                                                            if let &Opcode::Bnot = v29 {
                                                                if v2.0 == v19.0 {
                                                                    let v691 = constructor_band(ctx, v2.0, v30, v27);
                                                                    let v692 = constructor_bnot(ctx, v2.0, v691);
                                                                    // Rule at src/opts/bitops.isle line 289.
                                                                    returns.extend(Some(v692));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    let v693 = constructor_band(ctx, v2.0, v27, v30);
                                                                    let v694 = constructor_bnot(ctx, v2.0, v693);
                                                                    // Rule at src/opts/bitops.isle line 290.
                                                                    returns.extend(Some(v694));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let mut v626 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v27, &mut v626);
                                                let mut v626 = v626.into_context_iter();
                                                while let Some(v627) = v626.next(ctx) {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v630,
                                                        args: ref v631,
                                                    } = &v627.1 {
                                                        match v630 {
                                                            &Opcode::Bor => {
                                                                if v2.0 == v627.0 {
                                                                    let v632 = C::unpack_value_array_2(ctx, v631);
                                                                    if v7.0 == v632.0 {
                                                                        let v723 = constructor_bnot(ctx, v2.0, v632.1);
                                                                        let v724 = constructor_bor(ctx, v2.0, v7.0, v723);
                                                                        // Rule at src/opts/bitops.isle line 315.
                                                                        returns.extend(Some(v724));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v7.0 == v632.1 {
                                                                        let v719 = constructor_bnot(ctx, v2.0, v632.0);
                                                                        let v720 = constructor_bor(ctx, v2.0, v7.0, v719);
                                                                        // Rule at src/opts/bitops.isle line 313.
                                                                        returns.extend(Some(v720));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Bxor => {
                                                                if v2.0 == v627.0 {
                                                                    let v632 = C::unpack_value_array_2(ctx, v631);
                                                                    if v7.0 == v632.0 {
                                                                        let v723 = constructor_bnot(ctx, v2.0, v632.1);
                                                                        let v724 = constructor_bor(ctx, v2.0, v7.0, v723);
                                                                        // Rule at src/opts/bitops.isle line 554.
                                                                        returns.extend(Some(v724));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v7.0 == v632.1 {
                                                                        let v719 = constructor_bnot(ctx, v2.0, v632.0);
                                                                        let v720 = constructor_bor(ctx, v2.0, v7.0, v719);
                                                                        // Rule at src/opts/bitops.isle line 556.
                                                                        returns.extend(Some(v720));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                    }
                                                }
                                            }
                                            let v301 = C::ty_int_vec128(ctx, v2.0);
                                            if let Some(v302) = v301 {
                                                if v11.0 == v302 {
                                                    if v7.0 == v27 {
                                                        let v303 = constructor_iconst_s(ctx, v302, -1_i64);
                                                        let v304 = C::subsume(ctx, v303);
                                                        // Rule at src/opts/bitops.isle line 24.
                                                        returns.extend(Some(v304));
                                                        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 v1316 = C::value_type(ctx, v30);
                                                        let v1347 = C::value_type(ctx, v27);
                                                        if v1316 == v1347 {
                                                            let v1350 = constructor_bor(ctx, v1316, v30, v27);
                                                            let v1351 = constructor_uextend(ctx, v2.0, v1350);
                                                            // Rule at src/opts/extends.isle line 72.
                                                            returns.extend(Some(v1351));
                                                            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 v102,
                                                    args: ref v103,
                                                } = &v19.1 {
                                                    match v102 {
                                                        &Opcode::Band => {
                                                            if v2.0 == v19.0 {
                                                                let v104 = C::unpack_value_array_2(ctx, v103);
                                                                let mut v114 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                                let mut v114 = v114.into_context_iter();
                                                                while let Some(v115) = v114.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v132,
                                                                        imm: v133,
                                                                    } = &v115.1 {
                                                                        if let &Opcode::Iconst = v132 {
                                                                            let v310 = C::ty_mask(ctx, v2.0);
                                                                            let v16 = C::u64_from_imm64(ctx, v15);
                                                                            let v311 = C::u64_and(ctx, v310, v16);
                                                                            let v309 = C::u64_from_imm64(ctx, v133);
                                                                            let v312 = C::u64_not(ctx, v309);
                                                                            let v313 = C::u64_and(ctx, v310, v312);
                                                                            let v314 = C::u64_eq(ctx, v311, v313);
                                                                            if v314 == true {
                                                                                if v2.0 == v115.0 {
                                                                                    let v307 = constructor_bor(ctx, v2.0, v104.0, v7.1);
                                                                                    // Rule at src/opts/bitops.isle line 64.
                                                                                    returns.extend(Some(v307));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &Opcode::Bor => {
                                                            if v2.0 == v19.0 {
                                                                let v104 = C::unpack_value_array_2(ctx, v103);
                                                                let mut v114 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                                let mut v114 = v114.into_context_iter();
                                                                while let Some(v115) = v114.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v132,
                                                                        imm: v133,
                                                                    } = &v115.1 {
                                                                        if let &Opcode::Iconst = v132 {
                                                                            if v2.0 == v115.0 {
                                                                                let v1024 = constructor_bor(ctx, v2.0, v104.1, v7.1);
                                                                                let v1025 = constructor_bor(ctx, v2.0, v104.0, v1024);
                                                                                // Rule at src/opts/cprop.isle line 216.
                                                                                returns.extend(Some(v1025));
                                                                                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 v292 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v293) = v292 {
                                            if v11.0 == v293 {
                                                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 v934 = C::imm64_or(ctx, v293, v23, v15);
                                                                let v935 = constructor_iconst(ctx, v293, v934);
                                                                let v936 = C::subsume(ctx, v935);
                                                                // Rule at src/opts/cprop.isle line 55.
                                                                returns.extend(Some(v936));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        let v1572 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 17.
                                        returns.extend(Some(v1572));
                                        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 v102,
                                    args: ref v103,
                                } => {
                                    match v102 {
                                        &Opcode::Band => {
                                            if v2.0 == v19.0 {
                                                let v104 = C::unpack_value_array_2(ctx, v103);
                                                let mut v107 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v104.0, &mut v107);
                                                let mut v107 = v107.into_context_iter();
                                                while let Some(v108) = v107.next(ctx) {
                                                    match &v108.1 {
                                                        &InstructionData::Binary {
                                                            opcode: ref v342,
                                                            args: ref v343,
                                                        } => {
                                                            match v342 {
                                                                &Opcode::Bor => {
                                                                    if v2.0 == v108.0 {
                                                                        let v344 = C::unpack_value_array_2(ctx, v343);
                                                                        if v7.1 == v344.0 {
                                                                            let v821 = constructor_band(ctx, v2.0, v104.1, v344.1);
                                                                            let v822 = constructor_bor(ctx, v2.0, v821, v344.0);
                                                                            // Rule at src/opts/bitops.isle line 498.
                                                                            returns.extend(Some(v822));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.1 == v344.1 {
                                                                            let v829 = constructor_band(ctx, v2.0, v104.1, v344.0);
                                                                            let v830 = constructor_bor(ctx, v2.0, v829, v344.1);
                                                                            // Rule at src/opts/bitops.isle line 502.
                                                                            returns.extend(Some(v830));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Bxor => {
                                                                    if v2.0 == v108.0 {
                                                                        let v344 = C::unpack_value_array_2(ctx, v343);
                                                                        if v7.1 == v344.0 {
                                                                            let v791 = constructor_band(ctx, v2.0, v344.1, v104.1);
                                                                            let v792 = constructor_bor(ctx, v2.0, v791, v344.0);
                                                                            // Rule at src/opts/bitops.isle line 438.
                                                                            returns.extend(Some(v792));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.1 == v344.1 {
                                                                            let v783 = constructor_band(ctx, v2.0, v344.0, v104.1);
                                                                            let v784 = constructor_bor(ctx, v2.0, v783, v344.1);
                                                                            // Rule at src/opts/bitops.isle line 434.
                                                                            returns.extend(Some(v784));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v111,
                                                            arg: v112,
                                                        } => {
                                                            if let &Opcode::Bnot = v111 {
                                                                if v7.1 == v112 {
                                                                    if v2.0 == v108.0 {
                                                                        let v853 = constructor_bor(ctx, v2.0, v112, v104.1);
                                                                        // Rule at src/opts/bitops.isle line 533.
                                                                        returns.extend(Some(v853));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let mut v114 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                let mut v114 = v114.into_context_iter();
                                                while let Some(v115) = v114.next(ctx) {
                                                    match &v115.1 {
                                                        &InstructionData::Binary {
                                                            opcode: ref v354,
                                                            args: ref v355,
                                                        } => {
                                                            match v354 {
                                                                &Opcode::Bor => {
                                                                    if v2.0 == v115.0 {
                                                                        let v356 = C::unpack_value_array_2(ctx, v355);
                                                                        if v7.1 == v356.0 {
                                                                            let v817 = constructor_band(ctx, v2.0, v104.0, v356.1);
                                                                            let v818 = constructor_bor(ctx, v2.0, v817, v356.0);
                                                                            // Rule at src/opts/bitops.isle line 496.
                                                                            returns.extend(Some(v818));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.1 == v356.1 {
                                                                            let v825 = constructor_band(ctx, v2.0, v104.0, v356.0);
                                                                            let v826 = constructor_bor(ctx, v2.0, v825, v356.1);
                                                                            // Rule at src/opts/bitops.isle line 500.
                                                                            returns.extend(Some(v826));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Bxor => {
                                                                    if v2.0 == v115.0 {
                                                                        let v356 = C::unpack_value_array_2(ctx, v355);
                                                                        if v7.1 == v356.0 {
                                                                            let v795 = constructor_band(ctx, v2.0, v356.1, v104.0);
                                                                            let v796 = constructor_bor(ctx, v2.0, v795, v356.0);
                                                                            // Rule at src/opts/bitops.isle line 440.
                                                                            returns.extend(Some(v796));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.1 == v356.1 {
                                                                            let v787 = constructor_band(ctx, v2.0, v356.0, v104.0);
                                                                            let v788 = constructor_bor(ctx, v2.0, v787, v356.1);
                                                                            // Rule at src/opts/bitops.isle line 436.
                                                                            returns.extend(Some(v788));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v118,
                                                            arg: v119,
                                                        } => {
                                                            if let &Opcode::Bnot = v118 {
                                                                if v7.1 == v119 {
                                                                    if v2.0 == v115.0 {
                                                                        let v854 = constructor_bor(ctx, v2.0, v119, v104.0);
                                                                        // Rule at src/opts/bitops.isle line 535.
                                                                        returns.extend(Some(v854));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                if v7.1 == v104.0 {
                                                    // Rule at src/opts/bitops.isle line 212.
                                                    returns.extend(Some(v104.0));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        &Opcode::Bor => {
                                            if v2.0 == v19.0 {
                                                let v104 = C::unpack_value_array_2(ctx, v103);
                                                if v7.1 == v104.0 {
                                                    let v245 = constructor_bor(ctx, v2.0, v104.0, v104.1);
                                                    // Rule at src/opts/bitops.isle line 187.
                                                    returns.extend(Some(v245));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.1 == v104.1 {
                                                    let v245 = constructor_bor(ctx, v2.0, v104.0, v104.1);
                                                    // Rule at src/opts/bitops.isle line 188.
                                                    returns.extend(Some(v245));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        &Opcode::Bxor => {
                                            if v2.0 == v19.0 {
                                                let v104 = C::unpack_value_array_2(ctx, v103);
                                                let mut v107 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v104.0, &mut v107);
                                                let mut v107 = v107.into_context_iter();
                                                while let Some(v108) = v107.next(ctx) {
                                                    match &v108.1 {
                                                        &InstructionData::Binary {
                                                            opcode: ref v342,
                                                            args: ref v343,
                                                        } => {
                                                            match v342 {
                                                                &Opcode::Band => {
                                                                    if v2.0 == v108.0 {
                                                                        let v344 = C::unpack_value_array_2(ctx, v343);
                                                                        if v7.1 == v344.0 {
                                                                            let v845 = constructor_bor(ctx, v2.0, v104.1, v344.0);
                                                                            // Rule at src/opts/bitops.isle line 518.
                                                                            returns.extend(Some(v845));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.1 == v344.1 {
                                                                            let v837 = constructor_bor(ctx, v2.0, v104.1, v344.1);
                                                                            // Rule at src/opts/bitops.isle line 522.
                                                                            returns.extend(Some(v837));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Bxor => {
                                                                    if v2.0 == v108.0 {
                                                                        let v344 = C::unpack_value_array_2(ctx, v343);
                                                                        if v7.1 == v344.0 {
                                                                            let v695 = constructor_bxor(ctx, v2.0, v344.1, v104.1);
                                                                            let v696 = constructor_bor(ctx, v2.0, v695, v344.0);
                                                                            // Rule at src/opts/bitops.isle line 293.
                                                                            returns.extend(Some(v696));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.1 == v344.1 {
                                                                            let v703 = constructor_bxor(ctx, v2.0, v344.0, v104.1);
                                                                            let v704 = constructor_bor(ctx, v2.0, v703, v344.1);
                                                                            // Rule at src/opts/bitops.isle line 297.
                                                                            returns.extend(Some(v704));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v111,
                                                            arg: v112,
                                                        } => {
                                                            if let &Opcode::Bnot = v111 {
                                                                if v7.1 == v112 {
                                                                    if v2.0 == v108.0 {
                                                                        let v650 = constructor_bnot(ctx, v2.0, v104.1);
                                                                        let v858 = constructor_bor(ctx, v2.0, v112, v650);
                                                                        // Rule at src/opts/bitops.isle line 561.
                                                                        returns.extend(Some(v858));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let mut v114 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                let mut v114 = v114.into_context_iter();
                                                while let Some(v115) = v114.next(ctx) {
                                                    match &v115.1 {
                                                        &InstructionData::Binary {
                                                            opcode: ref v354,
                                                            args: ref v355,
                                                        } => {
                                                            match v354 {
                                                                &Opcode::Band => {
                                                                    if v2.0 == v115.0 {
                                                                        let v356 = C::unpack_value_array_2(ctx, v355);
                                                                        if v7.1 == v356.0 {
                                                                            let v841 = constructor_bor(ctx, v2.0, v104.0, v356.0);
                                                                            // Rule at src/opts/bitops.isle line 516.
                                                                            returns.extend(Some(v841));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.1 == v356.1 {
                                                                            let v833 = constructor_bor(ctx, v2.0, v104.0, v356.1);
                                                                            // Rule at src/opts/bitops.isle line 520.
                                                                            returns.extend(Some(v833));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Bxor => {
                                                                    if v2.0 == v115.0 {
                                                                        let v356 = C::unpack_value_array_2(ctx, v355);
                                                                        if v7.1 == v356.0 {
                                                                            let v699 = constructor_bxor(ctx, v2.0, v356.1, v104.0);
                                                                            let v700 = constructor_bor(ctx, v2.0, v699, v356.0);
                                                                            // Rule at src/opts/bitops.isle line 295.
                                                                            returns.extend(Some(v700));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.1 == v356.1 {
                                                                            let v707 = constructor_bxor(ctx, v2.0, v356.0, v104.0);
                                                                            let v708 = constructor_bor(ctx, v2.0, v707, v356.1);
                                                                            // Rule at src/opts/bitops.isle line 299.
                                                                            returns.extend(Some(v708));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v118,
                                                            arg: v119,
                                                        } => {
                                                            if let &Opcode::Bnot = v118 {
                                                                if v7.1 == v119 {
                                                                    if v2.0 == v115.0 {
                                                                        let v620 = constructor_bnot(ctx, v2.0, v104.0);
                                                                        let v860 = constructor_bor(ctx, v2.0, v119, v620);
                                                                        // Rule at src/opts/bitops.isle line 563.
                                                                        returns.extend(Some(v860));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                if v7.1 == v104.0 {
                                                    let v245 = constructor_bor(ctx, v2.0, v104.0, v104.1);
                                                    // Rule at src/opts/bitops.isle line 405.
                                                    returns.extend(Some(v245));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.1 == v104.1 {
                                                    let v246 = constructor_bor(ctx, v2.0, v104.1, v104.0);
                                                    // Rule at src/opts/bitops.isle line 407.
                                                    returns.extend(Some(v246));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v29,
                                    arg: v30,
                                } => {
                                    if let &Opcode::Bnot = v29 {
                                        if v2.0 == v19.0 {
                                            let mut v636 = C::inst_data_value_etor_returns::default();
                                            C::inst_data_value_etor(ctx, v30, &mut v636);
                                            let mut v636 = v636.into_context_iter();
                                            while let Some(v637) = v636.next(ctx) {
                                                if let &InstructionData::Binary {
                                                    opcode: ref v640,
                                                    args: ref v641,
                                                } = &v637.1 {
                                                    match v640 {
                                                        &Opcode::Bor => {
                                                            if v2.0 == v637.0 {
                                                                let v642 = C::unpack_value_array_2(ctx, v641);
                                                                if v7.1 == v642.0 {
                                                                    let v725 = constructor_bnot(ctx, v2.0, v642.1);
                                                                    let v726 = constructor_bor(ctx, v2.0, v642.0, v725);
                                                                    // Rule at src/opts/bitops.isle line 316.
                                                                    returns.extend(Some(v726));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v7.1 == v642.1 {
                                                                    let v721 = constructor_bnot(ctx, v2.0, v642.0);
                                                                    let v722 = constructor_bor(ctx, v2.0, v642.1, v721);
                                                                    // Rule at src/opts/bitops.isle line 314.
                                                                    returns.extend(Some(v722));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                        &Opcode::Bxor => {
                                                            if v2.0 == v637.0 {
                                                                let v642 = C::unpack_value_array_2(ctx, v641);
                                                                if v7.1 == v642.0 {
                                                                    let v725 = constructor_bnot(ctx, v2.0, v642.1);
                                                                    let v726 = constructor_bor(ctx, v2.0, v642.0, v725);
                                                                    // Rule at src/opts/bitops.isle line 555.
                                                                    returns.extend(Some(v726));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v7.1 == v642.1 {
                                                                    let v721 = constructor_bnot(ctx, v2.0, v642.0);
                                                                    let v722 = constructor_bor(ctx, v2.0, v642.1, v721);
                                                                    // Rule at src/opts/bitops.isle line 557.
                                                                    returns.extend(Some(v722));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                            }
                                        }
                                        if v7.1 == v30 {
                                            let v301 = C::ty_int_vec128(ctx, v2.0);
                                            if let Some(v302) = v301 {
                                                if v19.0 == v302 {
                                                    let v303 = constructor_iconst_s(ctx, v302, -1_i64);
                                                    let v304 = C::subsume(ctx, v303);
                                                    // Rule at src/opts/bitops.isle line 25.
                                                    returns.extend(Some(v304));
                                                    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 v996 = constructor_bor(ctx, v2.0, v7.1, v7.0);
                                            // Rule at src/opts/cprop.isle line 158.
                                            returns.extend(Some(v996));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        let v1572 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 15.
                                        returns.extend(Some(v1572));
                                        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 v138,
                                    args: ref v139,
                                } => {
                                    match v138 {
                                        &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 v102,
                                                        args: ref v103,
                                                    } = &v19.1 {
                                                        match v102 {
                                                            &Opcode::Band => {
                                                                if v2.0 == v19.0 {
                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let v140 = C::unpack_value_array_2(ctx, v139);
                                                                    if v104.0 == v140.0 {
                                                                        let v624 = constructor_bxor(ctx, v2.0, v104.1, v140.1);
                                                                        let v625 = constructor_band(ctx, v2.0, v104.0, v624);
                                                                        // Rule at src/opts/bitops.isle line 224.
                                                                        returns.extend(Some(v625));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Bor => {
                                                                if v2.0 == v19.0 {
                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let v140 = C::unpack_value_array_2(ctx, v139);
                                                                    if v104.0 == v140.0 {
                                                                        if v104.1 == v140.1 {
                                                                            let v243 = constructor_bxor(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/bitops.isle line 184.
                                                                            returns.extend(Some(v243));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                    }
                                                }
                                                let v140 = C::unpack_value_array_2(ctx, v139);
                                                let mut v382 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v140.0, &mut v382);
                                                let mut v382 = v382.into_context_iter();
                                                while let Some(v383) = v382.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v616,
                                                        arg: v617,
                                                    } = &v383.1 {
                                                        if let &Opcode::Bnot = v616 {
                                                            if v2.0 == v383.0 {
                                                                if v7.0 == v617 {
                                                                    let v608 = constructor_bor(ctx, v2.0, v7.0, v140.1);
                                                                    // Rule at src/opts/bitops.isle line 539.
                                                                    returns.extend(Some(v608));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                let v889 = constructor_band(ctx, v2.0, v617, v140.1);
                                                                let v890 = constructor_bxor(ctx, v2.0, v7.0, v140.1);
                                                                let v891 = constructor_bxor(ctx, v2.0, v889, v890);
                                                                // Rule at src/opts/bitops.isle line 607.
                                                                returns.extend(Some(v891));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                                let mut v414 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v140.1, &mut v414);
                                                let mut v414 = v414.into_context_iter();
                                                while let Some(v415) = v414.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v613,
                                                        arg: v614,
                                                    } = &v415.1 {
                                                        if let &Opcode::Bnot = v613 {
                                                            if v2.0 == v415.0 {
                                                                if v7.0 == v614 {
                                                                    let v772 = constructor_bor(ctx, v2.0, v7.0, v140.0);
                                                                    // Rule at src/opts/bitops.isle line 541.
                                                                    returns.extend(Some(v772));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                let v894 = constructor_band(ctx, v2.0, v614, v140.0);
                                                                let v895 = constructor_bxor(ctx, v2.0, v7.0, v140.0);
                                                                let v896 = constructor_bxor(ctx, v2.0, v894, v895);
                                                                // Rule at src/opts/bitops.isle line 609.
                                                                returns.extend(Some(v896));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Bor => {
                                            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) {
                                                    match &v19.1 {
                                                        &InstructionData::Binary {
                                                            opcode: ref v102,
                                                            args: ref v103,
                                                        } => {
                                                            match v102 {
                                                                &Opcode::Bor => {
                                                                    if v2.0 == v19.0 {
                                                                        let v104 = C::unpack_value_array_2(ctx, v103);
                                                                        let v140 = C::unpack_value_array_2(ctx, v139);
                                                                        if v104.0 == v140.0 {
                                                                            let mut v114 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                                            let mut v114 = v114.into_context_iter();
                                                                            while let Some(v115) = v114.next(ctx) {
                                                                                if let &InstructionData::Unary {
                                                                                    opcode: ref v118,
                                                                                    arg: v119,
                                                                                } = &v115.1 {
                                                                                    if let &Opcode::Bnot = v118 {
                                                                                        if v2.0 == v115.0 {
                                                                                            if v119 == v140.1 {
                                                                                                let v620 = constructor_bnot(ctx, v2.0, v104.0);
                                                                                                // Rule at src/opts/bitops.isle line 276.
                                                                                                returns.extend(Some(v620));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            let mut v414 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v140.1, &mut v414);
                                                                            let mut v414 = v414.into_context_iter();
                                                                            while let Some(v415) = v414.next(ctx) {
                                                                                if let &InstructionData::Unary {
                                                                                    opcode: ref v613,
                                                                                    arg: v614,
                                                                                } = &v415.1 {
                                                                                    if let &Opcode::Bnot = v613 {
                                                                                        if v104.1 == v614 {
                                                                                            if v2.0 == v415.0 {
                                                                                                let v620 = constructor_bnot(ctx, v2.0, v104.0);
                                                                                                // Rule at src/opts/bitops.isle line 275.
                                                                                                returns.extend(Some(v620));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        if v104.0 == v140.1 {
                                                                            let mut v114 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                                            let mut v114 = v114.into_context_iter();
                                                                            while let Some(v115) = v114.next(ctx) {
                                                                                if let &InstructionData::Unary {
                                                                                    opcode: ref v118,
                                                                                    arg: v119,
                                                                                } = &v115.1 {
                                                                                    if let &Opcode::Bnot = v118 {
                                                                                        if v119 == v140.0 {
                                                                                            if v2.0 == v115.0 {
                                                                                                let v620 = constructor_bnot(ctx, v2.0, v104.0);
                                                                                                // Rule at src/opts/bitops.isle line 280.
                                                                                                returns.extend(Some(v620));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            let mut v382 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v140.0, &mut v382);
                                                                            let mut v382 = v382.into_context_iter();
                                                                            while let Some(v383) = v382.next(ctx) {
                                                                                if let &InstructionData::Unary {
                                                                                    opcode: ref v616,
                                                                                    arg: v617,
                                                                                } = &v383.1 {
                                                                                    if let &Opcode::Bnot = v616 {
                                                                                        if v104.1 == v617 {
                                                                                            if v2.0 == v383.0 {
                                                                                                let v620 = constructor_bnot(ctx, v2.0, v104.0);
                                                                                                // Rule at src/opts/bitops.isle line 277.
                                                                                                returns.extend(Some(v620));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        if v104.1 == v140.0 {
                                                                            let mut v107 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v104.0, &mut v107);
                                                                            let mut v107 = v107.into_context_iter();
                                                                            while let Some(v108) = v107.next(ctx) {
                                                                                if let &InstructionData::Unary {
                                                                                    opcode: ref v111,
                                                                                    arg: v112,
                                                                                } = &v108.1 {
                                                                                    if let &Opcode::Bnot = v111 {
                                                                                        if v112 == v140.1 {
                                                                                            if v2.0 == v108.0 {
                                                                                                let v650 = constructor_bnot(ctx, v2.0, v104.1);
                                                                                                // Rule at src/opts/bitops.isle line 278.
                                                                                                returns.extend(Some(v650));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            let mut v414 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v140.1, &mut v414);
                                                                            let mut v414 = v414.into_context_iter();
                                                                            while let Some(v415) = v414.next(ctx) {
                                                                                if let &InstructionData::Unary {
                                                                                    opcode: ref v613,
                                                                                    arg: v614,
                                                                                } = &v415.1 {
                                                                                    if let &Opcode::Bnot = v613 {
                                                                                        if v104.0 == v614 {
                                                                                            if v2.0 == v415.0 {
                                                                                                let v650 = constructor_bnot(ctx, v2.0, v104.1);
                                                                                                // Rule at src/opts/bitops.isle line 279.
                                                                                                returns.extend(Some(v650));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        if v104.1 == v140.1 {
                                                                            let mut v107 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v104.0, &mut v107);
                                                                            let mut v107 = v107.into_context_iter();
                                                                            while let Some(v108) = v107.next(ctx) {
                                                                                if let &InstructionData::Unary {
                                                                                    opcode: ref v111,
                                                                                    arg: v112,
                                                                                } = &v108.1 {
                                                                                    if let &Opcode::Bnot = v111 {
                                                                                        if v112 == v140.0 {
                                                                                            if v2.0 == v108.0 {
                                                                                                let v650 = constructor_bnot(ctx, v2.0, v104.1);
                                                                                                // Rule at src/opts/bitops.isle line 282.
                                                                                                returns.extend(Some(v650));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            let mut v382 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v140.0, &mut v382);
                                                                            let mut v382 = v382.into_context_iter();
                                                                            while let Some(v383) = v382.next(ctx) {
                                                                                if let &InstructionData::Unary {
                                                                                    opcode: ref v616,
                                                                                    arg: v617,
                                                                                } = &v383.1 {
                                                                                    if let &Opcode::Bnot = v616 {
                                                                                        if v104.0 == v617 {
                                                                                            if v2.0 == v383.0 {
                                                                                                let v650 = constructor_bnot(ctx, v2.0, v104.1);
                                                                                                // Rule at src/opts/bitops.isle line 281.
                                                                                                returns.extend(Some(v650));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Bxor => {
                                                                    if v2.0 == v19.0 {
                                                                        let v104 = C::unpack_value_array_2(ctx, v103);
                                                                        let v140 = C::unpack_value_array_2(ctx, v139);
                                                                        if v104.0 == v140.0 {
                                                                            if v104.1 == v140.1 {
                                                                                let v247 = constructor_band(ctx, v2.0, v104.1, v104.0);
                                                                                // Rule at src/opts/bitops.isle line 425.
                                                                                returns.extend(Some(v247));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                let v143 = constructor_band(ctx, v2.0, v104.0, v104.1);
                                                                                // Rule at src/opts/bitops.isle line 431.
                                                                                returns.extend(Some(v143));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                            let mut v414 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v140.1, &mut v414);
                                                                            let mut v414 = v414.into_context_iter();
                                                                            while let Some(v415) = v414.next(ctx) {
                                                                                if let &InstructionData::Unary {
                                                                                    opcode: ref v613,
                                                                                    arg: v614,
                                                                                } = &v415.1 {
                                                                                    if let &Opcode::Bnot = v613 {
                                                                                        if v104.1 == v614 {
                                                                                            if v2.0 == v415.0 {
                                                                                                let v620 = constructor_bnot(ctx, v2.0, v104.0);
                                                                                                let v621 = constructor_bor(ctx, v2.0, v104.1, v620);
                                                                                                // Rule at src/opts/bitops.isle line 652.
                                                                                                returns.extend(Some(v621));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        if v104.0 == v140.1 {
                                                                            if v104.1 == v140.0 {
                                                                                let v143 = constructor_band(ctx, v2.0, v104.0, v104.1);
                                                                                // Rule at src/opts/bitops.isle line 427.
                                                                                returns.extend(Some(v143));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                let v247 = constructor_band(ctx, v2.0, v104.1, v104.0);
                                                                                // Rule at src/opts/bitops.isle line 429.
                                                                                returns.extend(Some(v247));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                            let mut v382 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v140.0, &mut v382);
                                                                            let mut v382 = v382.into_context_iter();
                                                                            while let Some(v383) = v382.next(ctx) {
                                                                                if let &InstructionData::Unary {
                                                                                    opcode: ref v616,
                                                                                    arg: v617,
                                                                                } = &v383.1 {
                                                                                    if let &Opcode::Bnot = v616 {
                                                                                        if v104.1 == v617 {
                                                                                            if v2.0 == v383.0 {
                                                                                                let v620 = constructor_bnot(ctx, v2.0, v104.0);
                                                                                                let v621 = constructor_bor(ctx, v2.0, v104.1, v620);
                                                                                                // Rule at src/opts/bitops.isle line 648.
                                                                                                returns.extend(Some(v621));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        if v104.1 == v140.0 {
                                                                            let mut v414 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v140.1, &mut v414);
                                                                            let mut v414 = v414.into_context_iter();
                                                                            while let Some(v415) = v414.next(ctx) {
                                                                                if let &InstructionData::Unary {
                                                                                    opcode: ref v613,
                                                                                    arg: v614,
                                                                                } = &v415.1 {
                                                                                    if let &Opcode::Bnot = v613 {
                                                                                        if v104.0 == v614 {
                                                                                            if v2.0 == v415.0 {
                                                                                                let v650 = constructor_bnot(ctx, v2.0, v104.1);
                                                                                                let v733 = constructor_bor(ctx, v2.0, v104.0, v650);
                                                                                                // Rule at src/opts/bitops.isle line 650.
                                                                                                returns.extend(Some(v733));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        if v104.1 == v140.1 {
                                                                            let mut v382 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v140.0, &mut v382);
                                                                            let mut v382 = v382.into_context_iter();
                                                                            while let Some(v383) = v382.next(ctx) {
                                                                                if let &InstructionData::Unary {
                                                                                    opcode: ref v616,
                                                                                    arg: v617,
                                                                                } = &v383.1 {
                                                                                    if let &Opcode::Bnot = v616 {
                                                                                        if v104.0 == v617 {
                                                                                            if v2.0 == v383.0 {
                                                                                                let v650 = constructor_bnot(ctx, v2.0, v104.1);
                                                                                                let v733 = constructor_bor(ctx, v2.0, v104.0, v650);
                                                                                                // Rule at src/opts/bitops.isle line 646.
                                                                                                returns.extend(Some(v733));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v29,
                                                            arg: v30,
                                                        } => {
                                                            if let &Opcode::Bnot = v29 {
                                                                if v2.0 == v19.0 {
                                                                    let v140 = C::unpack_value_array_2(ctx, v139);
                                                                    if v30 == v140.0 {
                                                                        let v731 = constructor_bnot(ctx, v2.0, v140.1);
                                                                        let v732 = constructor_bor(ctx, v2.0, v30, v731);
                                                                        // Rule at src/opts/bitops.isle line 325.
                                                                        returns.extend(Some(v732));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v30 == v140.1 {
                                                                        let v734 = constructor_bnot(ctx, v2.0, v140.0);
                                                                        let v735 = constructor_bor(ctx, v2.0, v30, v734);
                                                                        // Rule at src/opts/bitops.isle line 327.
                                                                        returns.extend(Some(v735));
                                                                        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 v102,
                                                        args: ref v103,
                                                    } = &v19.1 {
                                                        match v102 {
                                                            &Opcode::Band => {
                                                                if v2.0 == v19.0 {
                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let v140 = C::unpack_value_array_2(ctx, v139);
                                                                    if v104.0 == v140.0 {
                                                                        if v104.1 == v140.1 {
                                                                            let v245 = constructor_bor(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/bitops.isle line 38.
                                                                            returns.extend(Some(v245));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Bor => {
                                                                if v2.0 == v19.0 {
                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let v140 = C::unpack_value_array_2(ctx, v139);
                                                                    if v104.0 == v140.0 {
                                                                        if v104.1 == v140.1 {
                                                                            let v247 = constructor_band(ctx, v2.0, v104.1, v104.0);
                                                                            // Rule at src/opts/bitops.isle line 424.
                                                                            returns.extend(Some(v247));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            let v143 = constructor_band(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/bitops.isle line 430.
                                                                            returns.extend(Some(v143));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        let mut v114 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                                        let mut v114 = v114.into_context_iter();
                                                                        while let Some(v115) = v114.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v118,
                                                                                arg: v119,
                                                                            } = &v115.1 {
                                                                                if let &Opcode::Bnot = v118 {
                                                                                    if v119 == v140.1 {
                                                                                        if v2.0 == v115.0 {
                                                                                            let v620 = constructor_bnot(ctx, v2.0, v104.0);
                                                                                            let v860 = constructor_bor(ctx, v2.0, v119, v620);
                                                                                            // Rule at src/opts/bitops.isle line 651.
                                                                                            returns.extend(Some(v860));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        if v104.1 == v140.0 {
                                                                            let v247 = constructor_band(ctx, v2.0, v104.1, v104.0);
                                                                            // Rule at src/opts/bitops.isle line 426.
                                                                            returns.extend(Some(v247));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            let v143 = constructor_band(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/bitops.isle line 428.
                                                                            returns.extend(Some(v143));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        let mut v114 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                                        let mut v114 = v114.into_context_iter();
                                                                        while let Some(v115) = v114.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v118,
                                                                                arg: v119,
                                                                            } = &v115.1 {
                                                                                if let &Opcode::Bnot = v118 {
                                                                                    if v119 == v140.0 {
                                                                                        if v2.0 == v115.0 {
                                                                                            let v620 = constructor_bnot(ctx, v2.0, v104.0);
                                                                                            let v860 = constructor_bor(ctx, v2.0, v119, v620);
                                                                                            // Rule at src/opts/bitops.isle line 649.
                                                                                            returns.extend(Some(v860));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    let mut v107 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v104.0, &mut v107);
                                                                    let mut v107 = v107.into_context_iter();
                                                                    while let Some(v108) = v107.next(ctx) {
                                                                        if let &InstructionData::Unary {
                                                                            opcode: ref v111,
                                                                            arg: v112,
                                                                        } = &v108.1 {
                                                                            if let &Opcode::Bnot = v111 {
                                                                                if v2.0 == v108.0 {
                                                                                    if v112 == v140.0 {
                                                                                        if v104.1 == v140.1 {
                                                                                            let v650 = constructor_bnot(ctx, v2.0, v104.1);
                                                                                            let v858 = constructor_bor(ctx, v2.0, v112, v650);
                                                                                            // Rule at src/opts/bitops.isle line 645.
                                                                                            returns.extend(Some(v858));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                    if v112 == v140.1 {
                                                                                        if v104.1 == v140.0 {
                                                                                            let v650 = constructor_bnot(ctx, v2.0, v104.1);
                                                                                            let v858 = constructor_bor(ctx, v2.0, v112, v650);
                                                                                            // Rule at src/opts/bitops.isle line 647.
                                                                                            returns.extend(Some(v858));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Bxor => {
                                                                if v2.0 == v19.0 {
                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let mut v114 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                                    let mut v114 = v114.into_context_iter();
                                                                    while let Some(v115) = v114.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v132,
                                                                            imm: v133,
                                                                        } = &v115.1 {
                                                                            if let &Opcode::Iconst = v132 {
                                                                                let v140 = C::unpack_value_array_2(ctx, v139);
                                                                                let mut v414 = C::inst_data_value_etor_returns::default();
                                                                                C::inst_data_value_etor(ctx, v140.1, &mut v414);
                                                                                let mut v414 = v414.into_context_iter();
                                                                                while let Some(v415) = v414.next(ctx) {
                                                                                    if let &InstructionData::UnaryImm {
                                                                                        opcode: ref v1097,
                                                                                        imm: v1098,
                                                                                    } = &v415.1 {
                                                                                        if let &Opcode::Iconst = v1097 {
                                                                                            let v1109 = constructor_bxor(ctx, v2.0, v104.0, v140.0);
                                                                                            let v1110 = constructor_bxor(ctx, v2.0, v104.1, v140.1);
                                                                                            let v1111 = constructor_bxor(ctx, v2.0, v1109, v1110);
                                                                                            // Rule at src/opts/cprop.isle line 329.
                                                                                            returns.extend(Some(v1111));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                    }
                                                }
                                                let v140 = C::unpack_value_array_2(ctx, v139);
                                                if v7.0 == v140.1 {
                                                    // Rule at src/opts/bitops.isle line 217.
                                                    returns.extend(Some(v140.0));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    // Rule at src/opts/bitops.isle line 493.
                                                    returns.extend(Some(v140.0));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.0 == v140.0 {
                                                    // Rule at src/opts/bitops.isle line 491.
                                                    returns.extend(Some(v140.1));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::IntCompare {
                                    opcode: ref v742,
                                    args: ref v743,
                                    cond: ref v744,
                                } => {
                                    if let &Opcode::Icmp = v742 {
                                        match v744 {
                                            &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 v736,
                                                            args: ref v737,
                                                            cond: ref v738,
                                                        } = &v19.1 {
                                                            if let &Opcode::Icmp = v736 {
                                                                match v738 {
                                                                    &IntCC::SignedGreaterThan => {
                                                                        if v2.0 == v19.0 {
                                                                            let v739 = C::unpack_value_array_2(ctx, v737);
                                                                            let v745 = C::unpack_value_array_2(ctx, v743);
                                                                            if v739.0 == v745.1 {
                                                                                if v739.1 == v745.0 {
                                                                                    let v748 = constructor_ne(ctx, v2.0, v739.0, v739.1);
                                                                                    // Rule at src/opts/icmp.isle line 309.
                                                                                    returns.extend(Some(v748));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedLessThan => {
                                                                        if v2.0 == v19.0 {
                                                                            let v739 = C::unpack_value_array_2(ctx, v737);
                                                                            let v745 = C::unpack_value_array_2(ctx, v743);
                                                                            if v739.0 == v745.0 {
                                                                                if v739.1 == v745.1 {
                                                                                    let v748 = constructor_ne(ctx, v2.0, v739.0, v739.1);
                                                                                    // Rule at src/opts/icmp.isle line 311.
                                                                                    returns.extend(Some(v748));
                                                                                    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 v736,
                                                            args: ref v737,
                                                            cond: ref v738,
                                                        } = &v19.1 {
                                                            if let &Opcode::Icmp = v736 {
                                                                match v738 {
                                                                    &IntCC::SignedGreaterThan => {
                                                                        if v2.0 == v19.0 {
                                                                            let v739 = C::unpack_value_array_2(ctx, v737);
                                                                            let v745 = C::unpack_value_array_2(ctx, v743);
                                                                            if v739.0 == v745.0 {
                                                                                if v739.1 == v745.1 {
                                                                                    let v748 = constructor_ne(ctx, v2.0, v739.0, v739.1);
                                                                                    // Rule at src/opts/icmp.isle line 310.
                                                                                    returns.extend(Some(v748));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedLessThan => {
                                                                        if v2.0 == v19.0 {
                                                                            let v739 = C::unpack_value_array_2(ctx, v737);
                                                                            let v745 = C::unpack_value_array_2(ctx, v743);
                                                                            if v739.0 == v745.1 {
                                                                                if v739.1 == v745.0 {
                                                                                    let v748 = constructor_ne(ctx, v2.0, v739.0, v739.1);
                                                                                    // Rule at src/opts/icmp.isle line 312.
                                                                                    returns.extend(Some(v748));
                                                                                    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 v736,
                                                            args: ref v737,
                                                            cond: ref v738,
                                                        } = &v19.1 {
                                                            if let &Opcode::Icmp = v736 {
                                                                match v738 {
                                                                    &IntCC::UnsignedGreaterThan => {
                                                                        if v2.0 == v19.0 {
                                                                            let v739 = C::unpack_value_array_2(ctx, v737);
                                                                            let v745 = C::unpack_value_array_2(ctx, v743);
                                                                            if v739.0 == v745.1 {
                                                                                if v739.1 == v745.0 {
                                                                                    let v748 = constructor_ne(ctx, v2.0, v739.0, v739.1);
                                                                                    // Rule at src/opts/icmp.isle line 313.
                                                                                    returns.extend(Some(v748));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        if v2.0 == v19.0 {
                                                                            let v739 = C::unpack_value_array_2(ctx, v737);
                                                                            let v745 = C::unpack_value_array_2(ctx, v743);
                                                                            if v739.0 == v745.0 {
                                                                                if v739.1 == v745.1 {
                                                                                    let v748 = constructor_ne(ctx, v2.0, v739.0, v739.1);
                                                                                    // Rule at src/opts/icmp.isle line 315.
                                                                                    returns.extend(Some(v748));
                                                                                    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 v736,
                                                            args: ref v737,
                                                            cond: ref v738,
                                                        } = &v19.1 {
                                                            if let &Opcode::Icmp = v736 {
                                                                match v738 {
                                                                    &IntCC::UnsignedGreaterThan => {
                                                                        if v2.0 == v19.0 {
                                                                            let v739 = C::unpack_value_array_2(ctx, v737);
                                                                            let v745 = C::unpack_value_array_2(ctx, v743);
                                                                            if v739.0 == v745.0 {
                                                                                if v739.1 == v745.1 {
                                                                                    let v748 = constructor_ne(ctx, v2.0, v739.0, v739.1);
                                                                                    // Rule at src/opts/icmp.isle line 314.
                                                                                    returns.extend(Some(v748));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        if v2.0 == v19.0 {
                                                                            let v739 = C::unpack_value_array_2(ctx, v737);
                                                                            let v745 = C::unpack_value_array_2(ctx, v743);
                                                                            if v739.0 == v745.1 {
                                                                                if v739.1 == v745.0 {
                                                                                    let v748 = constructor_ne(ctx, v2.0, v739.0, v739.1);
                                                                                    // Rule at src/opts/icmp.isle line 316.
                                                                                    returns.extend(Some(v748));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v26,
                                    arg: v27,
                                } => {
                                    match v26 {
                                        &Opcode::Splat => {
                                            let v1953 = C::ty_vector_not_float(ctx, v2.0);
                                            if let Some(v1954) = v1953 {
                                                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 v1816 = C::lane_type(ctx, v2.0);
                                                                    let v1959 = constructor_bxor(ctx, v1816, v30, v27);
                                                                    let v1960 = constructor_splat(ctx, v2.0, v1959);
                                                                    // Rule at src/opts/vector.isle line 22.
                                                                    returns.extend(Some(v1960));
                                                                    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 v102,
                                                        args: ref v103,
                                                    } = &v19.1 {
                                                        if let &Opcode::Bor = v102 {
                                                            if v2.0 == v19.0 {
                                                                let v104 = C::unpack_value_array_2(ctx, v103);
                                                                if v27 == v104.0 {
                                                                    let v650 = constructor_bnot(ctx, v2.0, v104.1);
                                                                    let v733 = constructor_bor(ctx, v2.0, v104.0, v650);
                                                                    // Rule at src/opts/bitops.isle line 326.
                                                                    returns.extend(Some(v733));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v27 == v104.1 {
                                                                    let v620 = constructor_bnot(ctx, v2.0, v104.0);
                                                                    let v621 = constructor_bor(ctx, v2.0, v104.1, v620);
                                                                    // Rule at src/opts/bitops.isle line 328.
                                                                    returns.extend(Some(v621));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            let v301 = C::ty_int_vec128(ctx, v2.0);
                                            if let Some(v302) = v301 {
                                                if v11.0 == v302 {
                                                    if v7.0 == v27 {
                                                        let v303 = constructor_iconst_s(ctx, v302, -1_i64);
                                                        let v304 = C::subsume(ctx, v303);
                                                        // Rule at src/opts/bitops.isle line 22.
                                                        returns.extend(Some(v304));
                                                        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 v1316 = C::value_type(ctx, v30);
                                                        let v1347 = C::value_type(ctx, v27);
                                                        if v1316 == v1347 {
                                                            let v1352 = constructor_bxor(ctx, v1316, v30, v27);
                                                            let v1353 = constructor_uextend(ctx, v2.0, v1352);
                                                            // Rule at src/opts/extends.isle line 74.
                                                            returns.extend(Some(v1353));
                                                            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 v102,
                                                    args: ref v103,
                                                } = &v19.1 {
                                                    if let &Opcode::Bxor = v102 {
                                                        if v2.0 == v19.0 {
                                                            let v104 = C::unpack_value_array_2(ctx, v103);
                                                            let mut v114 = C::inst_data_value_etor_returns::default();
                                                            C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                            let mut v114 = v114.into_context_iter();
                                                            while let Some(v115) = v114.next(ctx) {
                                                                if let &InstructionData::UnaryImm {
                                                                    opcode: ref v132,
                                                                    imm: v133,
                                                                } = &v115.1 {
                                                                    if let &Opcode::Iconst = v132 {
                                                                        if v2.0 == v115.0 {
                                                                            let v1028 = constructor_bxor(ctx, v2.0, v104.1, v7.1);
                                                                            let v1029 = constructor_bxor(ctx, v2.0, v104.0, v1028);
                                                                            // Rule at src/opts/cprop.isle line 222.
                                                                            returns.extend(Some(v1029));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        let v292 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v293) = v292 {
                                            if v11.0 == v293 {
                                                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 v940 = C::imm64_xor(ctx, v293, v23, v15);
                                                                let v941 = constructor_iconst(ctx, v293, v940);
                                                                let v942 = C::subsume(ctx, v941);
                                                                // Rule at src/opts/cprop.isle line 67.
                                                                returns.extend(Some(v942));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        let v1572 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 21.
                                        returns.extend(Some(v1572));
                                        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 v102,
                                    args: ref v103,
                                } => {
                                    match v102 {
                                        &Opcode::Band => {
                                            if v2.0 == v19.0 {
                                                let v104 = C::unpack_value_array_2(ctx, v103);
                                                let mut v107 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v104.0, &mut v107);
                                                let mut v107 = v107.into_context_iter();
                                                while let Some(v108) = v107.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v111,
                                                        arg: v112,
                                                    } = &v108.1 {
                                                        if let &Opcode::Bnot = v111 {
                                                            if v2.0 == v108.0 {
                                                                if v7.1 == v112 {
                                                                    let v853 = constructor_bor(ctx, v2.0, v112, v104.1);
                                                                    // Rule at src/opts/bitops.isle line 538.
                                                                    returns.extend(Some(v853));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                let v850 = constructor_band(ctx, v2.0, v112, v104.1);
                                                                let v887 = constructor_bxor(ctx, v2.0, v7.1, v104.1);
                                                                let v888 = constructor_bxor(ctx, v2.0, v850, v887);
                                                                // Rule at src/opts/bitops.isle line 606.
                                                                returns.extend(Some(v888));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                                let mut v114 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                let mut v114 = v114.into_context_iter();
                                                while let Some(v115) = v114.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v118,
                                                        arg: v119,
                                                    } = &v115.1 {
                                                        if let &Opcode::Bnot = v118 {
                                                            if v2.0 == v115.0 {
                                                                if v7.1 == v119 {
                                                                    let v854 = constructor_bor(ctx, v2.0, v119, v104.0);
                                                                    // Rule at src/opts/bitops.isle line 540.
                                                                    returns.extend(Some(v854));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                let v852 = constructor_band(ctx, v2.0, v119, v104.0);
                                                                let v892 = constructor_bxor(ctx, v2.0, v7.1, v104.0);
                                                                let v893 = constructor_bxor(ctx, v2.0, v852, v892);
                                                                // Rule at src/opts/bitops.isle line 608.
                                                                returns.extend(Some(v893));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Bxor => {
                                            if v2.0 == v19.0 {
                                                let v104 = C::unpack_value_array_2(ctx, v103);
                                                if v7.1 == v104.1 {
                                                    // Rule at src/opts/bitops.isle line 216.
                                                    returns.extend(Some(v104.0));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    // Rule at src/opts/bitops.isle line 492.
                                                    returns.extend(Some(v104.0));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.1 == v104.0 {
                                                    // Rule at src/opts/bitops.isle line 490.
                                                    returns.extend(Some(v104.1));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v29,
                                    arg: v30,
                                } => {
                                    if let &Opcode::Bnot = v29 {
                                        if v7.1 == v30 {
                                            let v301 = C::ty_int_vec128(ctx, v2.0);
                                            if let Some(v302) = v301 {
                                                if v19.0 == v302 {
                                                    let v303 = constructor_iconst_s(ctx, v302, -1_i64);
                                                    let v304 = C::subsume(ctx, v303);
                                                    // Rule at src/opts/bitops.isle line 23.
                                                    returns.extend(Some(v304));
                                                    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 v998 = constructor_bxor(ctx, v2.0, v7.1, v7.0);
                                            // Rule at src/opts/cprop.isle line 164.
                                            returns.extend(Some(v998));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        let v1572 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 19.
                                        returns.extend(Some(v1572));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                _ => {}
                            }
                        }
                        if v7.0 == v7.1 {
                            let v297 = C::ty_int(ctx, v2.0);
                            if let Some(v298) = v297 {
                                let v299 = constructor_iconst_u(ctx, v298, 0x0_u64);
                                let v300 = C::subsume(ctx, v299);
                                // Rule at src/opts/bitops.isle line 17.
                                returns.extend(Some(v300));
                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                            }
                        }
                        let mut v56 = C::inst_data_value_tupled_etor_returns::default();
                        C::inst_data_value_tupled_etor(ctx, v7.1, &mut v56);
                        let mut v56 = v56.into_context_iter();
                        while let Some(v57) = v56.next(ctx) {
                            let v58 = C::iconst_sextend_etor(ctx, v57);
                            if let Some(v59) = v58 {
                                if v59.1 == -1_i64 {
                                    if v2.0 == v59.0 {
                                        let v315 = constructor_bnot(ctx, v2.0, v7.0);
                                        // Rule at src/opts/bitops.isle line 72.
                                        returns.extend(Some(v315));
                                        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 v138,
                                    args: ref v139,
                                } => {
                                    if let &Opcode::Iconcat = v138 {
                                        let v140 = C::unpack_value_array_2(ctx, v139);
                                        let v1812 = constructor_rotl(ctx, v2.0, v7.0, v140.0);
                                        // Rule at src/opts/shifts.isle line 142.
                                        returns.extend(Some(v1812));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v26,
                                    arg: v27,
                                } => {
                                    match v26 {
                                        &Opcode::Ireduce => {
                                            let v1347 = C::value_type(ctx, v27);
                                            let v1801 = C::fits_in_64(ctx, v1347);
                                            if let Some(v1802) = v1801 {
                                                let v1807 = constructor_rotl(ctx, v2.0, v7.0, v27);
                                                // Rule at src/opts/shifts.isle line 126.
                                                returns.extend(Some(v1807));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        &Opcode::Uextend => {
                                            let v1807 = constructor_rotl(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 127.
                                            returns.extend(Some(v1807));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Sextend => {
                                            let v1807 = constructor_rotl(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 128.
                                            returns.extend(Some(v1807));
                                            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 v102,
                                                    args: ref v103,
                                                } => {
                                                    match v102 {
                                                        &Opcode::Rotl => {
                                                            if v2.0 == v19.0 {
                                                                let v104 = C::unpack_value_array_2(ctx, v103);
                                                                let v1825 = constructor_iadd_uextend(ctx, v104.1, v7.1);
                                                                let v1826 = constructor_rotl(ctx, v2.0, v104.0, v1825);
                                                                // Rule at src/opts/shifts.isle line 239.
                                                                returns.extend(Some(v1826));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                        &Opcode::Rotr => {
                                                            if v2.0 == v19.0 {
                                                                let v104 = C::unpack_value_array_2(ctx, v103);
                                                                let v1828 = constructor_isub_uextend(ctx, v104.1, v7.1);
                                                                let v1830 = constructor_rotr(ctx, v2.0, v104.0, v1828);
                                                                // Rule at src/opts/shifts.isle line 246.
                                                                returns.extend(Some(v1830));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                &InstructionData::UnaryImm {
                                                    opcode: ref v22,
                                                    imm: v23,
                                                } => {
                                                    if let &Opcode::Iconst = v22 {
                                                        let v292 = C::fits_in_64(ctx, v2.0);
                                                        if let Some(v293) = v292 {
                                                            if v19.0 == v293 {
                                                                let v958 = C::imm64_rotl(ctx, v293, v23, v15);
                                                                let v959 = constructor_iconst(ctx, v293, v958);
                                                                let v960 = C::subsume(ctx, v959);
                                                                // Rule at src/opts/cprop.isle line 98.
                                                                returns.extend(Some(v960));
                                                                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 v316 = constructor_ty_shift_mask(ctx, v2.0);
                                        let v1814 = C::u64_and(ctx, v16, v316);
                                        let v1864 = C::u64_eq(ctx, v16, v1814);
                                        if v1864 == false {
                                            let v1865 = constructor_iconst_u(ctx, v11.0, v1814);
                                            let v1870 = constructor_rotl(ctx, v2.0, v7.0, v1865);
                                            // Rule at src/opts/shifts.isle line 308.
                                            returns.extend(Some(v1870));
                                            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 v102,
                                    args: ref v103,
                                } => {
                                    match v102 {
                                        &Opcode::Rotl => {
                                            if v2.0 == v19.0 {
                                                let v104 = C::unpack_value_array_2(ctx, v103);
                                                let v1831 = C::value_type(ctx, v104.1);
                                                let v1832 = C::value_type(ctx, v7.1);
                                                if v1831 == v1832 {
                                                    let v1825 = constructor_iadd_uextend(ctx, v104.1, v7.1);
                                                    let v1826 = constructor_rotl(ctx, v2.0, v104.0, v1825);
                                                    // Rule at src/opts/shifts.isle line 260.
                                                    returns.extend(Some(v1826));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let mut v114 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                let mut v114 = v114.into_context_iter();
                                                while let Some(v115) = v114.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v132,
                                                        imm: v133,
                                                    } = &v115.1 {
                                                        if let &Opcode::Iconst = v132 {
                                                            let v1825 = constructor_iadd_uextend(ctx, v104.1, v7.1);
                                                            let v1826 = constructor_rotl(ctx, v2.0, v104.0, v1825);
                                                            // Rule at src/opts/shifts.isle line 238.
                                                            returns.extend(Some(v1826));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Rotr => {
                                            if v2.0 == v19.0 {
                                                let v104 = C::unpack_value_array_2(ctx, v103);
                                                if v7.1 == v104.1 {
                                                    let v1824 = C::subsume(ctx, v104.0);
                                                    // Rule at src/opts/shifts.isle line 203.
                                                    returns.extend(Some(v1824));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let v1831 = C::value_type(ctx, v104.1);
                                                let v1832 = C::value_type(ctx, v7.1);
                                                if v1831 == v1832 {
                                                    let v1828 = constructor_isub_uextend(ctx, v104.1, v7.1);
                                                    let v1830 = constructor_rotr(ctx, v2.0, v104.0, v1828);
                                                    // Rule at src/opts/shifts.isle line 265.
                                                    returns.extend(Some(v1830));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let mut v114 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                let mut v114 = v114.into_context_iter();
                                                while let Some(v115) = v114.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v132,
                                                        imm: v133,
                                                    } = &v115.1 {
                                                        if let &Opcode::Iconst = v132 {
                                                            let v1828 = constructor_isub_uextend(ctx, v104.1, v7.1);
                                                            let v1830 = constructor_rotr(ctx, v2.0, v104.0, v1828);
                                                            // Rule at src/opts/shifts.isle line 245.
                                                            returns.extend(Some(v1830));
                                                            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 v1816 = C::lane_type(ctx, v2.0);
                                            let v1987 = constructor_rotl(ctx, v1816, v30, v7.1);
                                            let v1988 = constructor_splat(ctx, v2.0, v1987);
                                            // Rule at src/opts/vector.isle line 68.
                                            returns.extend(Some(v1988));
                                            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 v138,
                                    args: ref v139,
                                } => {
                                    if let &Opcode::Iconcat = v138 {
                                        let v140 = C::unpack_value_array_2(ctx, v139);
                                        let v1811 = constructor_rotr(ctx, v2.0, v7.0, v140.0);
                                        // Rule at src/opts/shifts.isle line 141.
                                        returns.extend(Some(v1811));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                &InstructionData::Ternary {
                                    opcode: ref v1833,
                                    args: ref v1834,
                                } => {
                                    if let &Opcode::Select = v1833 {
                                        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::UnaryImm {
                                                    opcode: ref v22,
                                                    imm: v23,
                                                } = &v19.1 {
                                                    if let &Opcode::Iconst = v22 {
                                                        if v2.0 == v19.0 {
                                                            let v1835 = C::unpack_value_array_3(ctx, v1834);
                                                            let mut v1839 = C::inst_data_value_etor_returns::default();
                                                            C::inst_data_value_etor(ctx, v1835.1, &mut v1839);
                                                            let mut v1839 = v1839.into_context_iter();
                                                            while let Some(v1840) = v1839.next(ctx) {
                                                                if let &InstructionData::UnaryImm {
                                                                    opcode: ref v1843,
                                                                    imm: v1844,
                                                                } = &v1840.1 {
                                                                    if let &Opcode::Iconst = v1843 {
                                                                        if v2.0 == v1840.0 {
                                                                            let mut v1845 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v1835.2, &mut v1845);
                                                                            let mut v1845 = v1845.into_context_iter();
                                                                            while let Some(v1846) = v1845.next(ctx) {
                                                                                if let &InstructionData::UnaryImm {
                                                                                    opcode: ref v1849,
                                                                                    imm: v1850,
                                                                                } = &v1846.1 {
                                                                                    if let &Opcode::Iconst = v1849 {
                                                                                        if v2.0 == v1846.0 {
                                                                                            let v1851 = C::imm64_rotr(ctx, v2.0, v23, v1844);
                                                                                            let v1852 = constructor_iconst(ctx, v2.0, v1851);
                                                                                            let v1853 = C::imm64_rotr(ctx, v2.0, v23, v1850);
                                                                                            let v1854 = constructor_iconst(ctx, v2.0, v1853);
                                                                                            let v1855 = constructor_select(ctx, v2.0, v1835.0, v1852, v1854);
                                                                                            // Rule at src/opts/shifts.isle line 269.
                                                                                            returns.extend(Some(v1855));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v26,
                                    arg: v27,
                                } => {
                                    match v26 {
                                        &Opcode::Ireduce => {
                                            let v1347 = C::value_type(ctx, v27);
                                            let v1801 = C::fits_in_64(ctx, v1347);
                                            if let Some(v1802) = v1801 {
                                                let v1806 = constructor_rotr(ctx, v2.0, v7.0, v27);
                                                // Rule at src/opts/shifts.isle line 123.
                                                returns.extend(Some(v1806));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        &Opcode::Uextend => {
                                            let v1806 = constructor_rotr(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 124.
                                            returns.extend(Some(v1806));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Sextend => {
                                            let v1806 = constructor_rotr(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 125.
                                            returns.extend(Some(v1806));
                                            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 v102,
                                                    args: ref v103,
                                                } => {
                                                    match v102 {
                                                        &Opcode::Rotl => {
                                                            if v2.0 == v19.0 {
                                                                let v104 = C::unpack_value_array_2(ctx, v103);
                                                                let v1828 = constructor_isub_uextend(ctx, v104.1, v7.1);
                                                                let v1829 = constructor_rotl(ctx, v2.0, v104.0, v1828);
                                                                // Rule at src/opts/shifts.isle line 244.
                                                                returns.extend(Some(v1829));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                        &Opcode::Rotr => {
                                                            if v2.0 == v19.0 {
                                                                let v104 = C::unpack_value_array_2(ctx, v103);
                                                                let v1825 = constructor_iadd_uextend(ctx, v104.1, v7.1);
                                                                let v1827 = constructor_rotr(ctx, v2.0, v104.0, v1825);
                                                                // Rule at src/opts/shifts.isle line 241.
                                                                returns.extend(Some(v1827));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                &InstructionData::UnaryImm {
                                                    opcode: ref v22,
                                                    imm: v23,
                                                } => {
                                                    if let &Opcode::Iconst = v22 {
                                                        let v292 = C::fits_in_64(ctx, v2.0);
                                                        if let Some(v293) = v292 {
                                                            if v19.0 == v293 {
                                                                let v955 = C::imm64_rotr(ctx, v293, v23, v15);
                                                                let v956 = constructor_iconst(ctx, v293, v955);
                                                                let v957 = C::subsume(ctx, v956);
                                                                // Rule at src/opts/cprop.isle line 93.
                                                                returns.extend(Some(v957));
                                                                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 v316 = constructor_ty_shift_mask(ctx, v2.0);
                                        let v1814 = C::u64_and(ctx, v16, v316);
                                        let v1864 = C::u64_eq(ctx, v16, v1814);
                                        if v1864 == false {
                                            let v1865 = constructor_iconst_u(ctx, v11.0, v1814);
                                            let v1869 = constructor_rotr(ctx, v2.0, v7.0, v1865);
                                            // Rule at src/opts/shifts.isle line 305.
                                            returns.extend(Some(v1869));
                                            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 v102,
                                    args: ref v103,
                                } => {
                                    match v102 {
                                        &Opcode::Rotl => {
                                            if v2.0 == v19.0 {
                                                let v104 = C::unpack_value_array_2(ctx, v103);
                                                if v7.1 == v104.1 {
                                                    let v1824 = C::subsume(ctx, v104.0);
                                                    // Rule at src/opts/shifts.isle line 204.
                                                    returns.extend(Some(v1824));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let v1831 = C::value_type(ctx, v104.1);
                                                let v1832 = C::value_type(ctx, v7.1);
                                                if v1831 == v1832 {
                                                    let v1828 = constructor_isub_uextend(ctx, v104.1, v7.1);
                                                    let v1829 = constructor_rotl(ctx, v2.0, v104.0, v1828);
                                                    // Rule at src/opts/shifts.isle line 263.
                                                    returns.extend(Some(v1829));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let mut v114 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                let mut v114 = v114.into_context_iter();
                                                while let Some(v115) = v114.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v132,
                                                        imm: v133,
                                                    } = &v115.1 {
                                                        if let &Opcode::Iconst = v132 {
                                                            let v1828 = constructor_isub_uextend(ctx, v104.1, v7.1);
                                                            let v1829 = constructor_rotl(ctx, v2.0, v104.0, v1828);
                                                            // Rule at src/opts/shifts.isle line 243.
                                                            returns.extend(Some(v1829));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Rotr => {
                                            if v2.0 == v19.0 {
                                                let v104 = C::unpack_value_array_2(ctx, v103);
                                                let v1831 = C::value_type(ctx, v104.1);
                                                let v1832 = C::value_type(ctx, v7.1);
                                                if v1831 == v1832 {
                                                    let v1825 = constructor_iadd_uextend(ctx, v104.1, v7.1);
                                                    let v1827 = constructor_rotr(ctx, v2.0, v104.0, v1825);
                                                    // Rule at src/opts/shifts.isle line 258.
                                                    returns.extend(Some(v1827));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let mut v114 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                let mut v114 = v114.into_context_iter();
                                                while let Some(v115) = v114.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v132,
                                                        imm: v133,
                                                    } = &v115.1 {
                                                        if let &Opcode::Iconst = v132 {
                                                            let v1825 = constructor_iadd_uextend(ctx, v104.1, v7.1);
                                                            let v1827 = constructor_rotr(ctx, v2.0, v104.0, v1825);
                                                            // Rule at src/opts/shifts.isle line 240.
                                                            returns.extend(Some(v1827));
                                                            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 v1816 = C::lane_type(ctx, v2.0);
                                            let v1989 = constructor_rotr(ctx, v1816, v30, v7.1);
                                            let v1990 = constructor_splat(ctx, v2.0, v1989);
                                            // Rule at src/opts/vector.isle line 71.
                                            returns.extend(Some(v1990));
                                            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 v138,
                                    args: ref v139,
                                } => {
                                    if let &Opcode::Iconcat = v138 {
                                        let v140 = C::unpack_value_array_2(ctx, v139);
                                        let v1808 = constructor_ishl(ctx, v2.0, v7.0, v140.0);
                                        // Rule at src/opts/shifts.isle line 138.
                                        returns.extend(Some(v1808));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v26,
                                    arg: v27,
                                } => {
                                    match v26 {
                                        &Opcode::Ireduce => {
                                            let v1347 = C::value_type(ctx, v27);
                                            let v1801 = C::fits_in_64(ctx, v1347);
                                            if let Some(v1802) = v1801 {
                                                let v1803 = constructor_ishl(ctx, v2.0, v7.0, v27);
                                                // Rule at src/opts/shifts.isle line 114.
                                                returns.extend(Some(v1803));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        &Opcode::Uextend => {
                                            let v1803 = constructor_ishl(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 115.
                                            returns.extend(Some(v1803));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Sextend => {
                                            let v1803 = constructor_ishl(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 116.
                                            returns.extend(Some(v1803));
                                            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 v102,
                                                    args: ref v103,
                                                } => {
                                                    match v102 {
                                                        &Opcode::Ishl => {
                                                            if v2.0 == v19.0 {
                                                                let v104 = C::unpack_value_array_2(ctx, v103);
                                                                let mut v114 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                                let mut v114 = v114.into_context_iter();
                                                                while let Some(v115) = v114.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v132,
                                                                        imm: v133,
                                                                    } = &v115.1 {
                                                                        if let &Opcode::Iconst = v132 {
                                                                            let v309 = C::u64_from_imm64(ctx, v133);
                                                                            let v316 = constructor_ty_shift_mask(ctx, v2.0);
                                                                            let v1813 = C::u64_and(ctx, v309, v316);
                                                                            let v16 = C::u64_from_imm64(ctx, v15);
                                                                            let v1814 = C::u64_and(ctx, v16, v316);
                                                                            let v1815 = C::u64_wrapping_add(ctx, v1813, v1814);
                                                                            let v1816 = C::lane_type(ctx, v2.0);
                                                                            let v1817 = C::ty_bits_u64(ctx, v1816);
                                                                            let v1818 = C::u64_lt(ctx, v1815, v1817);
                                                                            if v1818 == true {
                                                                                let v1819 = constructor_iconst_u(ctx, v115.0, v1815);
                                                                                let v1820 = constructor_ishl(ctx, v2.0, v104.0, v1819);
                                                                                // Rule at src/opts/shifts.isle line 151.
                                                                                returns.extend(Some(v1820));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                            let v1782 = C::ty_bits_u64(ctx, v2.0);
                                                                            let v1823 = C::u64_lt_eq(ctx, v1782, v1815);
                                                                            if v1823 == true {
                                                                                let v53 = constructor_iconst_u(ctx, v2.0, 0x0_u64);
                                                                                let v54 = C::subsume(ctx, v53);
                                                                                // Rule at src/opts/shifts.isle line 183.
                                                                                returns.extend(Some(v54));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                let mut v107 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v104.0, &mut v107);
                                                                let mut v107 = v107.into_context_iter();
                                                                while let Some(v108) = v107.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v1010,
                                                                        imm: v1011,
                                                                    } = &v108.1 {
                                                                        if let &Opcode::Iconst = v1010 {
                                                                            let v1091 = constructor_ishl(ctx, v2.0, v104.0, v7.1);
                                                                            let v1092 = constructor_ishl(ctx, v2.0, v1091, v104.1);
                                                                            // Rule at src/opts/cprop.isle line 300.
                                                                            returns.extend(Some(v1092));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &Opcode::Ushr => {
                                                            let v292 = C::fits_in_64(ctx, v2.0);
                                                            if let Some(v293) = v292 {
                                                                if v19.0 == v293 {
                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let mut v114 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                                    let mut v114 = v114.into_context_iter();
                                                                    while let Some(v115) = v114.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v132,
                                                                            imm: v133,
                                                                        } = &v115.1 {
                                                                            if let &Opcode::Iconst = v132 {
                                                                                if v15 == v133 {
                                                                                    let v1773 = C::imm64(ctx, 0xffffffffffffffff_u64);
                                                                                    let v1774 = C::imm64_shl(ctx, v293, v1773, v133);
                                                                                    let v1775 = constructor_iconst(ctx, v293, v1774);
                                                                                    let v1776 = constructor_band(ctx, v293, v104.0, v1775);
                                                                                    // Rule at src/opts/shifts.isle line 26.
                                                                                    returns.extend(Some(v1776));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &Opcode::Sshr => {
                                                            let v292 = C::fits_in_64(ctx, v2.0);
                                                            if let Some(v293) = v292 {
                                                                if v19.0 == v293 {
                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let mut v114 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                                    let mut v114 = v114.into_context_iter();
                                                                    while let Some(v115) = v114.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v132,
                                                                            imm: v133,
                                                                        } = &v115.1 {
                                                                            if let &Opcode::Iconst = v132 {
                                                                                if v15 == v133 {
                                                                                    let v1773 = C::imm64(ctx, 0xffffffffffffffff_u64);
                                                                                    let v1774 = C::imm64_shl(ctx, v293, v1773, v133);
                                                                                    let v1775 = constructor_iconst(ctx, v293, v1774);
                                                                                    let v1776 = constructor_band(ctx, v293, v104.0, v1775);
                                                                                    // Rule at src/opts/shifts.isle line 31.
                                                                                    returns.extend(Some(v1776));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                &InstructionData::UnaryImm {
                                                    opcode: ref v22,
                                                    imm: v23,
                                                } => {
                                                    if let &Opcode::Iconst = v22 {
                                                        let v292 = C::fits_in_64(ctx, v2.0);
                                                        if let Some(v293) = v292 {
                                                            if v19.0 == v293 {
                                                                let v946 = C::imm64_shl(ctx, v293, v23, v15);
                                                                let v947 = constructor_iconst(ctx, v293, v946);
                                                                let v948 = C::subsume(ctx, v947);
                                                                // Rule at src/opts/cprop.isle line 78.
                                                                returns.extend(Some(v948));
                                                                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 v316 = constructor_ty_shift_mask(ctx, v2.0);
                                        let v1814 = C::u64_and(ctx, v16, v316);
                                        let v1864 = C::u64_eq(ctx, v16, v1814);
                                        if v1864 == false {
                                            let v1865 = constructor_iconst_u(ctx, v11.0, v1814);
                                            let v1866 = constructor_ishl(ctx, v2.0, v7.0, v1865);
                                            // Rule at src/opts/shifts.isle line 296.
                                            returns.extend(Some(v1866));
                                            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 v1816 = C::lane_type(ctx, v2.0);
                                        let v1991 = constructor_ishl(ctx, v1816, v30, v7.1);
                                        let v1992 = constructor_splat(ctx, v2.0, v1991);
                                        // Rule at src/opts/vector.isle line 74.
                                        returns.extend(Some(v1992));
                                        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 v138,
                                    args: ref v139,
                                } => {
                                    if let &Opcode::Iconcat = v138 {
                                        let v140 = C::unpack_value_array_2(ctx, v139);
                                        let v1809 = constructor_ushr(ctx, v2.0, v7.0, v140.0);
                                        // Rule at src/opts/shifts.isle line 139.
                                        returns.extend(Some(v1809));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v26,
                                    arg: v27,
                                } => {
                                    match v26 {
                                        &Opcode::Ireduce => {
                                            let v1347 = C::value_type(ctx, v27);
                                            let v1801 = C::fits_in_64(ctx, v1347);
                                            if let Some(v1802) = v1801 {
                                                let v1804 = constructor_ushr(ctx, v2.0, v7.0, v27);
                                                // Rule at src/opts/shifts.isle line 117.
                                                returns.extend(Some(v1804));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        &Opcode::Uextend => {
                                            let v1804 = constructor_ushr(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 118.
                                            returns.extend(Some(v1804));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Sextend => {
                                            let v1804 = constructor_ushr(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 119.
                                            returns.extend(Some(v1804));
                                            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 v102,
                                                    args: ref v103,
                                                } => {
                                                    match v102 {
                                                        &Opcode::Imul => {
                                                            let v121 = C::ty_half_width(ctx, v2.0);
                                                            if let Some(v122) = v121 {
                                                                if v2.0 == v19.0 {
                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let mut v107 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v104.0, &mut v107);
                                                                    let mut v107 = v107.into_context_iter();
                                                                    while let Some(v108) = v107.next(ctx) {
                                                                        if let &InstructionData::Unary {
                                                                            opcode: ref v111,
                                                                            arg: v112,
                                                                        } = &v108.1 {
                                                                            if let &Opcode::Uextend = v111 {
                                                                                let v113 = C::value_type(ctx, v112);
                                                                                let v123 = C::ty_equal(ctx, v113, v122);
                                                                                if v123 == true {
                                                                                    let v16 = C::u64_from_imm64(ctx, v15);
                                                                                    let v124 = C::ty_bits_u64(ctx, v113);
                                                                                    let v125 = C::u64_eq(ctx, v16, v124);
                                                                                    if v125 == true {
                                                                                        let mut v114 = C::inst_data_value_etor_returns::default();
                                                                                        C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                                                        let mut v114 = v114.into_context_iter();
                                                                                        while let Some(v115) = v114.next(ctx) {
                                                                                            if let &InstructionData::Unary {
                                                                                                opcode: ref v118,
                                                                                                arg: v119,
                                                                                            } = &v115.1 {
                                                                                                if let &Opcode::Uextend = v118 {
                                                                                                    let v120 = C::value_type(ctx, v119);
                                                                                                    if v113 == v120 {
                                                                                                        let v128 = constructor_umulhi(ctx, v113, v112, v119);
                                                                                                        let v129 = constructor_uextend(ctx, v2.0, v128);
                                                                                                        // Rule at src/opts/arithmetic.isle line 207.
                                                                                                        returns.extend(Some(v129));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &Opcode::Ishl => {
                                                            let v104 = C::unpack_value_array_2(ctx, v103);
                                                            let mut v114 = C::inst_data_value_etor_returns::default();
                                                            C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                            let mut v114 = v114.into_context_iter();
                                                            while let Some(v115) = v114.next(ctx) {
                                                                if let &InstructionData::UnaryImm {
                                                                    opcode: ref v132,
                                                                    imm: v133,
                                                                } = &v115.1 {
                                                                    if let &Opcode::Iconst = v132 {
                                                                        if v15 == v133 {
                                                                            let v292 = C::fits_in_64(ctx, v2.0);
                                                                            if let Some(v293) = v292 {
                                                                                let v1424 = C::ty_int(ctx, v293);
                                                                                if let Some(v1425) = v1424 {
                                                                                    if v19.0 == v1425 {
                                                                                        let v1777 = C::ty_mask(ctx, v1425);
                                                                                        let v1778 = C::imm64(ctx, v1777);
                                                                                        let v1779 = C::imm64_ushr(ctx, v1425, v1778, v133);
                                                                                        let v1780 = constructor_iconst(ctx, v1425, v1779);
                                                                                        let v1781 = constructor_band(ctx, v1425, v104.0, v1780);
                                                                                        // Rule at src/opts/shifts.isle line 40.
                                                                                        returns.extend(Some(v1781));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                            let v297 = C::ty_int(ctx, v2.0);
                                                                            if let Some(v298) = v297 {
                                                                                let v309 = C::u64_from_imm64(ctx, v133);
                                                                                let v1788 = C::u64_matches_non_zero(ctx, v309);
                                                                                if let Some(v1789) = v1788 {
                                                                                    if v1789 == true {
                                                                                        let v1790 = C::ty_bits(ctx, v298);
                                                                                        let v1791 = C::u8_into_u64(ctx, v1790);
                                                                                        let v1792 = C::u64_wrapping_sub(ctx, v1791, v309);
                                                                                        let v1793 = constructor_shift_amt_to_type(ctx, v1792);
                                                                                        if let Some(v1794) = v1793 {
                                                                                            if v19.0 == v298 {
                                                                                                let v1795 = constructor_ireduce(ctx, v1794, v104.0);
                                                                                                let v1797 = constructor_uextend(ctx, v298, v1795);
                                                                                                // Rule at src/opts/shifts.isle line 87.
                                                                                                returns.extend(Some(v1797));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &Opcode::Ushr => {
                                                            if v2.0 == v19.0 {
                                                                let v104 = C::unpack_value_array_2(ctx, v103);
                                                                let mut v114 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                                let mut v114 = v114.into_context_iter();
                                                                while let Some(v115) = v114.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v132,
                                                                        imm: v133,
                                                                    } = &v115.1 {
                                                                        if let &Opcode::Iconst = v132 {
                                                                            let v309 = C::u64_from_imm64(ctx, v133);
                                                                            let v316 = constructor_ty_shift_mask(ctx, v2.0);
                                                                            let v1813 = C::u64_and(ctx, v309, v316);
                                                                            let v16 = C::u64_from_imm64(ctx, v15);
                                                                            let v1814 = C::u64_and(ctx, v16, v316);
                                                                            let v1815 = C::u64_wrapping_add(ctx, v1813, v1814);
                                                                            let v1816 = C::lane_type(ctx, v2.0);
                                                                            let v1817 = C::ty_bits_u64(ctx, v1816);
                                                                            let v1818 = C::u64_lt(ctx, v1815, v1817);
                                                                            if v1818 == true {
                                                                                let v1819 = constructor_iconst_u(ctx, v115.0, v1815);
                                                                                let v1821 = constructor_ushr(ctx, v2.0, v104.0, v1819);
                                                                                // Rule at src/opts/shifts.isle line 160.
                                                                                returns.extend(Some(v1821));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                            let v1782 = C::ty_bits_u64(ctx, v2.0);
                                                                            let v1823 = C::u64_lt_eq(ctx, v1782, v1815);
                                                                            if v1823 == true {
                                                                                let v53 = constructor_iconst_u(ctx, v2.0, 0x0_u64);
                                                                                let v54 = C::subsume(ctx, v53);
                                                                                // Rule at src/opts/shifts.isle line 192.
                                                                                returns.extend(Some(v54));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                let mut v107 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v104.0, &mut v107);
                                                                let mut v107 = v107.into_context_iter();
                                                                while let Some(v108) = v107.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v1010,
                                                                        imm: v1011,
                                                                    } = &v108.1 {
                                                                        if let &Opcode::Iconst = v1010 {
                                                                            let v1093 = constructor_ushr(ctx, v2.0, v104.0, v7.1);
                                                                            let v1094 = constructor_ushr(ctx, v2.0, v1093, v104.1);
                                                                            // Rule at src/opts/cprop.isle line 302.
                                                                            returns.extend(Some(v1094));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                &InstructionData::UnaryImm {
                                                    opcode: ref v22,
                                                    imm: v23,
                                                } => {
                                                    if let &Opcode::Iconst = v22 {
                                                        let v292 = C::fits_in_64(ctx, v2.0);
                                                        if let Some(v293) = v292 {
                                                            if v19.0 == v293 {
                                                                let v949 = C::imm64_ushr(ctx, v293, v23, v15);
                                                                let v950 = constructor_iconst(ctx, v293, v949);
                                                                let v951 = C::subsume(ctx, v950);
                                                                // Rule at src/opts/cprop.isle line 83.
                                                                returns.extend(Some(v951));
                                                                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 v316 = constructor_ty_shift_mask(ctx, v2.0);
                                        let v1814 = C::u64_and(ctx, v16, v316);
                                        let v1864 = C::u64_eq(ctx, v16, v1814);
                                        if v1864 == false {
                                            let v1865 = constructor_iconst_u(ctx, v11.0, v1814);
                                            let v1867 = constructor_ushr(ctx, v2.0, v7.0, v1865);
                                            // Rule at src/opts/shifts.isle line 299.
                                            returns.extend(Some(v1867));
                                            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 v102,
                                    args: ref v103,
                                } => {
                                    if let &Opcode::Band = v102 {
                                        if v2.0 == v19.0 {
                                            let v104 = C::unpack_value_array_2(ctx, v103);
                                            let mut v107 = C::inst_data_value_etor_returns::default();
                                            C::inst_data_value_etor(ctx, v104.0, &mut v107);
                                            let mut v107 = v107.into_context_iter();
                                            while let Some(v108) = v107.next(ctx) {
                                                if let &InstructionData::Binary {
                                                    opcode: ref v342,
                                                    args: ref v343,
                                                } = &v108.1 {
                                                    if let &Opcode::Ishl = v342 {
                                                        if v2.0 == v108.0 {
                                                            let v344 = C::unpack_value_array_2(ctx, v343);
                                                            if v7.1 == v344.1 {
                                                                let v1875 = constructor_ushr(ctx, v2.0, v104.1, v344.1);
                                                                let v1876 = constructor_band(ctx, v2.0, v344.0, v1875);
                                                                // Rule at src/opts/shifts.isle line 316.
                                                                returns.extend(Some(v1876));
                                                                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 v1816 = C::lane_type(ctx, v2.0);
                                            let v1993 = constructor_ushr(ctx, v1816, v30, v7.1);
                                            let v1994 = constructor_splat(ctx, v2.0, v1993);
                                            // Rule at src/opts/vector.isle line 77.
                                            returns.extend(Some(v1994));
                                            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 v138,
                                    args: ref v139,
                                } => {
                                    if let &Opcode::Iconcat = v138 {
                                        let v140 = C::unpack_value_array_2(ctx, v139);
                                        let v1810 = constructor_sshr(ctx, v2.0, v7.0, v140.0);
                                        // Rule at src/opts/shifts.isle line 140.
                                        returns.extend(Some(v1810));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v26,
                                    arg: v27,
                                } => {
                                    match v26 {
                                        &Opcode::Ireduce => {
                                            let v1347 = C::value_type(ctx, v27);
                                            let v1801 = C::fits_in_64(ctx, v1347);
                                            if let Some(v1802) = v1801 {
                                                let v1805 = constructor_sshr(ctx, v2.0, v7.0, v27);
                                                // Rule at src/opts/shifts.isle line 120.
                                                returns.extend(Some(v1805));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        &Opcode::Uextend => {
                                            let v1805 = constructor_sshr(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 121.
                                            returns.extend(Some(v1805));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Sextend => {
                                            let v1805 = constructor_sshr(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 122.
                                            returns.extend(Some(v1805));
                                            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 v102,
                                                    args: ref v103,
                                                } => {
                                                    match v102 {
                                                        &Opcode::Imul => {
                                                            let v121 = C::ty_half_width(ctx, v2.0);
                                                            if let Some(v122) = v121 {
                                                                if v2.0 == v19.0 {
                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                    let mut v107 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v104.0, &mut v107);
                                                                    let mut v107 = v107.into_context_iter();
                                                                    while let Some(v108) = v107.next(ctx) {
                                                                        if let &InstructionData::Unary {
                                                                            opcode: ref v111,
                                                                            arg: v112,
                                                                        } = &v108.1 {
                                                                            if let &Opcode::Sextend = v111 {
                                                                                let v113 = C::value_type(ctx, v112);
                                                                                let v123 = C::ty_equal(ctx, v113, v122);
                                                                                if v123 == true {
                                                                                    let v16 = C::u64_from_imm64(ctx, v15);
                                                                                    let v124 = C::ty_bits_u64(ctx, v113);
                                                                                    let v125 = C::u64_eq(ctx, v16, v124);
                                                                                    if v125 == true {
                                                                                        let mut v114 = C::inst_data_value_etor_returns::default();
                                                                                        C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                                                        let mut v114 = v114.into_context_iter();
                                                                                        while let Some(v115) = v114.next(ctx) {
                                                                                            if let &InstructionData::Unary {
                                                                                                opcode: ref v118,
                                                                                                arg: v119,
                                                                                            } = &v115.1 {
                                                                                                if let &Opcode::Sextend = v118 {
                                                                                                    let v120 = C::value_type(ctx, v119);
                                                                                                    if v113 == v120 {
                                                                                                        let v126 = constructor_smulhi(ctx, v113, v112, v119);
                                                                                                        let v127 = constructor_sextend(ctx, v2.0, v126);
                                                                                                        // Rule at src/opts/arithmetic.isle line 201.
                                                                                                        returns.extend(Some(v127));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &Opcode::Bor => {
                                                            let v16 = C::u64_from_imm64(ctx, v15);
                                                            let v316 = constructor_ty_shift_mask(ctx, v2.0);
                                                            let v317 = C::u64_eq(ctx, v16, v316);
                                                            if v317 == true {
                                                                if v2.0 == v11.0 {
                                                                    if v2.0 == v19.0 {
                                                                        let v104 = C::unpack_value_array_2(ctx, v103);
                                                                        let mut v107 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v104.0, &mut v107);
                                                                        let mut v107 = v107.into_context_iter();
                                                                        while let Some(v108) = v107.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v111,
                                                                                arg: v112,
                                                                            } = &v108.1 {
                                                                                if let &Opcode::Ineg = v111 {
                                                                                    if v2.0 == v108.0 {
                                                                                        if v104.1 == v112 {
                                                                                            let v319 = constructor_bmask(ctx, v2.0, v112);
                                                                                            // Rule at src/opts/bitops.isle line 83.
                                                                                            returns.extend(Some(v319));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let mut v114 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                                        let mut v114 = v114.into_context_iter();
                                                                        while let Some(v115) = v114.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v118,
                                                                                arg: v119,
                                                                            } = &v115.1 {
                                                                                if let &Opcode::Ineg = v118 {
                                                                                    if v104.0 == v119 {
                                                                                        if v2.0 == v115.0 {
                                                                                            let v318 = constructor_bmask(ctx, v2.0, v104.0);
                                                                                            // Rule at src/opts/bitops.isle line 79.
                                                                                            returns.extend(Some(v318));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &Opcode::Ishl => {
                                                            let v104 = C::unpack_value_array_2(ctx, v103);
                                                            let mut v114 = C::inst_data_value_etor_returns::default();
                                                            C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                            let mut v114 = v114.into_context_iter();
                                                            while let Some(v115) = v114.next(ctx) {
                                                                if let &InstructionData::UnaryImm {
                                                                    opcode: ref v132,
                                                                    imm: v133,
                                                                } = &v115.1 {
                                                                    if let &Opcode::Iconst = v132 {
                                                                        if v2.0 == v19.0 {
                                                                            let v16 = C::u64_from_imm64(ctx, v15);
                                                                            let v309 = C::u64_from_imm64(ctx, v133);
                                                                            if v16 == v309 {
                                                                                let mut v107 = C::inst_data_value_etor_returns::default();
                                                                                C::inst_data_value_etor(ctx, v104.0, &mut v107);
                                                                                let mut v107 = v107.into_context_iter();
                                                                                while let Some(v108) = v107.next(ctx) {
                                                                                    if let &InstructionData::Unary {
                                                                                        opcode: ref v111,
                                                                                        arg: v112,
                                                                                    } = &v108.1 {
                                                                                        match v111 {
                                                                                            &Opcode::Uextend => {
                                                                                                if v2.0 == v108.0 {
                                                                                                    let v1782 = C::ty_bits_u64(ctx, v2.0);
                                                                                                    let v113 = C::value_type(ctx, v112);
                                                                                                    let v124 = C::ty_bits_u64(ctx, v113);
                                                                                                    let v1783 = C::u64_wrapping_sub(ctx, v1782, v124);
                                                                                                    let v1784 = C::u64_eq(ctx, v309, v1783);
                                                                                                    if v1784 == true {
                                                                                                        let v1785 = constructor_sextend(ctx, v2.0, v112);
                                                                                                        // Rule at src/opts/shifts.isle line 49.
                                                                                                        returns.extend(Some(v1785));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                    let v1786 = C::u64_lt(ctx, v309, v1783);
                                                                                                    if v1786 == true {
                                                                                                        // Rule at src/opts/shifts.isle line 60.
                                                                                                        returns.extend(Some(v104.0));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                            &Opcode::Sextend => {
                                                                                                let v1782 = C::ty_bits_u64(ctx, v2.0);
                                                                                                let v113 = C::value_type(ctx, v112);
                                                                                                let v124 = C::ty_bits_u64(ctx, v113);
                                                                                                let v1783 = C::u64_wrapping_sub(ctx, v1782, v124);
                                                                                                let v1787 = C::u64_lt_eq(ctx, v309, v1783);
                                                                                                if v1787 == true {
                                                                                                    if v2.0 == v108.0 {
                                                                                                        // Rule at src/opts/shifts.isle line 70.
                                                                                                        returns.extend(Some(v104.0));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                            _ => {}
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        if v15 == v133 {
                                                                            let v297 = C::ty_int(ctx, v2.0);
                                                                            if let Some(v298) = v297 {
                                                                                if v19.0 == v298 {
                                                                                    let v309 = C::u64_from_imm64(ctx, v133);
                                                                                    let v1788 = C::u64_matches_non_zero(ctx, v309);
                                                                                    if let Some(v1789) = v1788 {
                                                                                        if v1789 == true {
                                                                                            let v1790 = C::ty_bits(ctx, v298);
                                                                                            let v1791 = C::u8_into_u64(ctx, v1790);
                                                                                            let v1792 = C::u64_wrapping_sub(ctx, v1791, v309);
                                                                                            let v1793 = constructor_shift_amt_to_type(ctx, v1792);
                                                                                            if let Some(v1794) = v1793 {
                                                                                                let v1795 = constructor_ireduce(ctx, v1794, v104.0);
                                                                                                let v1796 = constructor_sextend(ctx, v298, v1795);
                                                                                                // Rule at src/opts/shifts.isle line 83.
                                                                                                returns.extend(Some(v1796));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &Opcode::Sshr => {
                                                            if v2.0 == v19.0 {
                                                                let v104 = C::unpack_value_array_2(ctx, v103);
                                                                let mut v107 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v104.0, &mut v107);
                                                                let mut v107 = v107.into_context_iter();
                                                                while let Some(v108) = v107.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v1010,
                                                                        imm: v1011,
                                                                    } = &v108.1 {
                                                                        if let &Opcode::Iconst = v1010 {
                                                                            let v1095 = constructor_sshr(ctx, v2.0, v104.0, v7.1);
                                                                            let v1096 = constructor_sshr(ctx, v2.0, v1095, v104.1);
                                                                            // Rule at src/opts/cprop.isle line 304.
                                                                            returns.extend(Some(v1096));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                let mut v114 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v104.1, &mut v114);
                                                                let mut v114 = v114.into_context_iter();
                                                                while let Some(v115) = v114.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v132,
                                                                        imm: v133,
                                                                    } = &v115.1 {
                                                                        if let &Opcode::Iconst = v132 {
                                                                            let v309 = C::u64_from_imm64(ctx, v133);
                                                                            let v316 = constructor_ty_shift_mask(ctx, v2.0);
                                                                            let v1813 = C::u64_and(ctx, v309, v316);
                                                                            let v16 = C::u64_from_imm64(ctx, v15);
                                                                            let v1814 = C::u64_and(ctx, v16, v316);
                                                                            let v1815 = C::u64_wrapping_add(ctx, v1813, v1814);
                                                                            let v1816 = C::lane_type(ctx, v2.0);
                                                                            let v1817 = C::ty_bits_u64(ctx, v1816);
                                                                            let v1818 = C::u64_lt(ctx, v1815, v1817);
                                                                            if v1818 == true {
                                                                                let v1819 = constructor_iconst_u(ctx, v115.0, v1815);
                                                                                let v1822 = constructor_sshr(ctx, v2.0, v104.0, v1819);
                                                                                // Rule at src/opts/shifts.isle line 169.
                                                                                returns.extend(Some(v1822));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                &InstructionData::UnaryImm {
                                                    opcode: ref v22,
                                                    imm: v23,
                                                } => {
                                                    if let &Opcode::Iconst = v22 {
                                                        let v292 = C::fits_in_64(ctx, v2.0);
                                                        if let Some(v293) = v292 {
                                                            if v19.0 == v293 {
                                                                let v952 = C::imm64_sshr(ctx, v293, v23, v15);
                                                                let v953 = constructor_iconst(ctx, v293, v952);
                                                                let v954 = C::subsume(ctx, v953);
                                                                // Rule at src/opts/cprop.isle line 88.
                                                                returns.extend(Some(v954));
                                                                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 v316 = constructor_ty_shift_mask(ctx, v2.0);
                                        let v1814 = C::u64_and(ctx, v16, v316);
                                        let v1864 = C::u64_eq(ctx, v16, v1814);
                                        if v1864 == false {
                                            let v1865 = constructor_iconst_u(ctx, v11.0, v1814);
                                            let v1868 = constructor_sshr(ctx, v2.0, v7.0, v1865);
                                            // Rule at src/opts/shifts.isle line 302.
                                            returns.extend(Some(v1868));
                                            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 v1816 = C::lane_type(ctx, v2.0);
                                        let v1995 = constructor_sshr(ctx, v1816, v30, v7.1);
                                        let v1996 = constructor_splat(ctx, v2.0, v1995);
                                        // Rule at src/opts/vector.isle line 80.
                                        returns.extend(Some(v1996));
                                        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 v1136,
                                            imm: v1137,
                                        } = &v11.1 {
                                            if let &Opcode::F32const = v1136 {
                                                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 v1134,
                                                            imm: v1135,
                                                        } = &v19.1 {
                                                            if let &Opcode::F32const = v1134 {
                                                                let v1138 = C::f32_add(ctx, v1135, v1137);
                                                                if let Some(v1139) = v1138 {
                                                                    let v1140 = constructor_f32const(ctx, F32, v1139);
                                                                    let v1141 = C::subsume(ctx, v1140);
                                                                    // Rule at src/opts/cprop.isle line 378.
                                                                    returns.extend(Some(v1141));
                                                                    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 v1144,
                                            imm: v1145,
                                        } = &v11.1 {
                                            if let &Opcode::F64const = v1144 {
                                                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 v1142,
                                                            imm: v1143,
                                                        } = &v19.1 {
                                                            if let &Opcode::F64const = v1142 {
                                                                let v1146 = C::f64_add(ctx, v1143, v1145);
                                                                if let Some(v1147) = v1146 {
                                                                    let v1148 = constructor_f64const(ctx, F64, v1147);
                                                                    let v1149 = C::subsume(ctx, v1148);
                                                                    // Rule at src/opts/cprop.isle line 381.
                                                                    returns.extend(Some(v1149));
                                                                    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 v1136,
                                            imm: v1137,
                                        } = &v11.1 {
                                            if let &Opcode::F32const = v1136 {
                                                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 v1134,
                                                            imm: v1135,
                                                        } = &v19.1 {
                                                            if let &Opcode::F32const = v1134 {
                                                                let v1150 = C::f32_sub(ctx, v1135, v1137);
                                                                if let Some(v1151) = v1150 {
                                                                    let v1152 = constructor_f32const(ctx, F32, v1151);
                                                                    let v1153 = C::subsume(ctx, v1152);
                                                                    // Rule at src/opts/cprop.isle line 385.
                                                                    returns.extend(Some(v1153));
                                                                    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 v1144,
                                            imm: v1145,
                                        } = &v11.1 {
                                            if let &Opcode::F64const = v1144 {
                                                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 v1142,
                                                            imm: v1143,
                                                        } = &v19.1 {
                                                            if let &Opcode::F64const = v1142 {
                                                                let v1154 = C::f64_sub(ctx, v1143, v1145);
                                                                if let Some(v1155) = v1154 {
                                                                    let v1156 = constructor_f64const(ctx, F64, v1155);
                                                                    let v1157 = C::subsume(ctx, v1156);
                                                                    // Rule at src/opts/cprop.isle line 388.
                                                                    returns.extend(Some(v1157));
                                                                    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 v101 = constructor_fmul(ctx, v2.0, v30, v27);
                                                            // Rule at src/opts/arithmetic.isle line 195.
                                                            returns.extend(Some(v101));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryIeee32 {
                                    opcode: ref v1136,
                                    imm: v1137,
                                } => {
                                    if let &Opcode::F32const = v1136 {
                                        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 v1134,
                                                            imm: v1135,
                                                        } = &v19.1 {
                                                            if let &Opcode::F32const = v1134 {
                                                                let v1158 = C::f32_mul(ctx, v1135, v1137);
                                                                if let Some(v1159) = v1158 {
                                                                    let v1160 = constructor_f32const(ctx, F32, v1159);
                                                                    let v1161 = C::subsume(ctx, v1160);
                                                                    // Rule at src/opts/cprop.isle line 392.
                                                                    returns.extend(Some(v1161));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryIeee64 {
                                    opcode: ref v1144,
                                    imm: v1145,
                                } => {
                                    if let &Opcode::F64const = v1144 {
                                        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 v1142,
                                                            imm: v1143,
                                                        } = &v19.1 {
                                                            if let &Opcode::F64const = v1142 {
                                                                let v1162 = C::f64_mul(ctx, v1143, v1145);
                                                                if let Some(v1163) = v1162 {
                                                                    let v1164 = constructor_f64const(ctx, F64, v1163);
                                                                    let v1165 = C::subsume(ctx, v1164);
                                                                    // Rule at src/opts/cprop.isle line 395.
                                                                    returns.extend(Some(v1165));
                                                                    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 v1136,
                                            imm: v1137,
                                        } = &v11.1 {
                                            if let &Opcode::F32const = v1136 {
                                                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 v1134,
                                                            imm: v1135,
                                                        } = &v19.1 {
                                                            if let &Opcode::F32const = v1134 {
                                                                let v1166 = C::f32_div(ctx, v1135, v1137);
                                                                if let Some(v1167) = v1166 {
                                                                    let v1168 = constructor_f32const(ctx, F32, v1167);
                                                                    let v1169 = C::subsume(ctx, v1168);
                                                                    // Rule at src/opts/cprop.isle line 399.
                                                                    returns.extend(Some(v1169));
                                                                    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 v1144,
                                            imm: v1145,
                                        } = &v11.1 {
                                            if let &Opcode::F64const = v1144 {
                                                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 v1142,
                                                            imm: v1143,
                                                        } = &v19.1 {
                                                            if let &Opcode::F64const = v1142 {
                                                                let v1170 = C::f64_div(ctx, v1143, v1145);
                                                                if let Some(v1171) = v1170 {
                                                                    let v1172 = constructor_f64const(ctx, F64, v1171);
                                                                    let v1173 = C::subsume(ctx, v1172);
                                                                    // Rule at src/opts/cprop.isle line 402.
                                                                    returns.extend(Some(v1173));
                                                                    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 v1216,
                                            imm: v1217,
                                        } = &v11.1 {
                                            if let &Opcode::F16const = v1216 {
                                                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 v1214,
                                                            imm: v1215,
                                                        } = &v19.1 {
                                                            if let &Opcode::F16const = v1214 {
                                                                let v1294 = C::f16_copysign(ctx, v1215, v1217);
                                                                let v1295 = constructor_f16const(ctx, F16, v1294);
                                                                let v1296 = C::subsume(ctx, v1295);
                                                                // Rule at src/opts/cprop.isle line 485.
                                                                returns.extend(Some(v1296));
                                                                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 v1136,
                                            imm: v1137,
                                        } = &v11.1 {
                                            if let &Opcode::F32const = v1136 {
                                                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 v1134,
                                                            imm: v1135,
                                                        } = &v19.1 {
                                                            if let &Opcode::F32const = v1134 {
                                                                let v1297 = C::f32_copysign(ctx, v1135, v1137);
                                                                let v1298 = constructor_f32const(ctx, F32, v1297);
                                                                let v1299 = C::subsume(ctx, v1298);
                                                                // Rule at src/opts/cprop.isle line 487.
                                                                returns.extend(Some(v1299));
                                                                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 v1144,
                                            imm: v1145,
                                        } = &v11.1 {
                                            if let &Opcode::F64const = v1144 {
                                                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 v1142,
                                                            imm: v1143,
                                                        } = &v19.1 {
                                                            if let &Opcode::F64const = v1142 {
                                                                let v1300 = C::f64_copysign(ctx, v1143, v1145);
                                                                let v1301 = constructor_f64const(ctx, F64, v1300);
                                                                let v1302 = C::subsume(ctx, v1301);
                                                                // Rule at src/opts/cprop.isle line 489.
                                                                returns.extend(Some(v1302));
                                                                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 v1235,
                                            constant_handle: v1236,
                                        } = &v11.1 {
                                            if let &Opcode::F128const = v1235 {
                                                let v1237 = C::ieee128_constant_extractor(ctx, v1236);
                                                if let Some(v1238) = v1237 {
                                                    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 v1231,
                                                                constant_handle: v1232,
                                                            } = &v19.1 {
                                                                if let &Opcode::F128const = v1231 {
                                                                    let v1233 = C::ieee128_constant_extractor(ctx, v1232);
                                                                    if let Some(v1234) = v1233 {
                                                                        let v1303 = C::f128_copysign(ctx, v1234, v1238);
                                                                        let v1304 = C::ieee128_constant(ctx, v1303);
                                                                        let v1305 = constructor_f128const(ctx, F128, v1304);
                                                                        let v1306 = C::subsume(ctx, v1305);
                                                                        // Rule at src/opts/cprop.isle line 491.
                                                                        returns.extend(Some(v1306));
                                                                        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 v1216,
                                            imm: v1217,
                                        } = &v11.1 {
                                            if let &Opcode::F16const = v1216 {
                                                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 v1214,
                                                            imm: v1215,
                                                        } = &v19.1 {
                                                            if let &Opcode::F16const = v1214 {
                                                                let v1218 = C::f16_min(ctx, v1215, v1217);
                                                                if let Some(v1219) = v1218 {
                                                                    let v1221 = constructor_f16const(ctx, F16, v1219);
                                                                    let v1222 = C::subsume(ctx, v1221);
                                                                    // Rule at src/opts/cprop.isle line 441.
                                                                    returns.extend(Some(v1222));
                                                                    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 v1136,
                                            imm: v1137,
                                        } = &v11.1 {
                                            if let &Opcode::F32const = v1136 {
                                                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 v1134,
                                                            imm: v1135,
                                                        } = &v19.1 {
                                                            if let &Opcode::F32const = v1134 {
                                                                let v1223 = C::f32_min(ctx, v1135, v1137);
                                                                if let Some(v1224) = v1223 {
                                                                    let v1225 = constructor_f32const(ctx, F32, v1224);
                                                                    let v1226 = C::subsume(ctx, v1225);
                                                                    // Rule at src/opts/cprop.isle line 444.
                                                                    returns.extend(Some(v1226));
                                                                    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 v1144,
                                            imm: v1145,
                                        } = &v11.1 {
                                            if let &Opcode::F64const = v1144 {
                                                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 v1142,
                                                            imm: v1143,
                                                        } = &v19.1 {
                                                            if let &Opcode::F64const = v1142 {
                                                                let v1227 = C::f64_min(ctx, v1143, v1145);
                                                                if let Some(v1228) = v1227 {
                                                                    let v1229 = constructor_f64const(ctx, F64, v1228);
                                                                    let v1230 = C::subsume(ctx, v1229);
                                                                    // Rule at src/opts/cprop.isle line 447.
                                                                    returns.extend(Some(v1230));
                                                                    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 v1235,
                                            constant_handle: v1236,
                                        } = &v11.1 {
                                            if let &Opcode::F128const = v1235 {
                                                let v1237 = C::ieee128_constant_extractor(ctx, v1236);
                                                if let Some(v1238) = v1237 {
                                                    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 v1231,
                                                                constant_handle: v1232,
                                                            } = &v19.1 {
                                                                if let &Opcode::F128const = v1231 {
                                                                    let v1233 = C::ieee128_constant_extractor(ctx, v1232);
                                                                    if let Some(v1234) = v1233 {
                                                                        let v1239 = C::f128_min(ctx, v1234, v1238);
                                                                        if let Some(v1240) = v1239 {
                                                                            let v1242 = C::ieee128_constant(ctx, v1240);
                                                                            let v1243 = constructor_f128const(ctx, F128, v1242);
                                                                            let v1244 = C::subsume(ctx, v1243);
                                                                            // Rule at src/opts/cprop.isle line 450.
                                                                            returns.extend(Some(v1244));
                                                                            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 v1216,
                                            imm: v1217,
                                        } = &v11.1 {
                                            if let &Opcode::F16const = v1216 {
                                                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 v1214,
                                                            imm: v1215,
                                                        } = &v19.1 {
                                                            if let &Opcode::F16const = v1214 {
                                                                let v1245 = C::f16_max(ctx, v1215, v1217);
                                                                if let Some(v1246) = v1245 {
                                                                    let v1247 = constructor_f16const(ctx, F16, v1246);
                                                                    let v1248 = C::subsume(ctx, v1247);
                                                                    // Rule at src/opts/cprop.isle line 454.
                                                                    returns.extend(Some(v1248));
                                                                    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 v1136,
                                            imm: v1137,
                                        } = &v11.1 {
                                            if let &Opcode::F32const = v1136 {
                                                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 v1134,
                                                            imm: v1135,
                                                        } = &v19.1 {
                                                            if let &Opcode::F32const = v1134 {
                                                                let v1249 = C::f32_max(ctx, v1135, v1137);
                                                                if let Some(v1250) = v1249 {
                                                                    let v1251 = constructor_f32const(ctx, F32, v1250);
                                                                    let v1252 = C::subsume(ctx, v1251);
                                                                    // Rule at src/opts/cprop.isle line 457.
                                                                    returns.extend(Some(v1252));
                                                                    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 v1144,
                                            imm: v1145,
                                        } = &v11.1 {
                                            if let &Opcode::F64const = v1144 {
                                                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 v1142,
                                                            imm: v1143,
                                                        } = &v19.1 {
                                                            if let &Opcode::F64const = v1142 {
                                                                let v1253 = C::f64_max(ctx, v1143, v1145);
                                                                if let Some(v1254) = v1253 {
                                                                    let v1255 = constructor_f64const(ctx, F64, v1254);
                                                                    let v1256 = C::subsume(ctx, v1255);
                                                                    // Rule at src/opts/cprop.isle line 460.
                                                                    returns.extend(Some(v1256));
                                                                    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 v1235,
                                            constant_handle: v1236,
                                        } = &v11.1 {
                                            if let &Opcode::F128const = v1235 {
                                                let v1237 = C::ieee128_constant_extractor(ctx, v1236);
                                                if let Some(v1238) = v1237 {
                                                    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 v1231,
                                                                constant_handle: v1232,
                                                            } = &v19.1 {
                                                                if let &Opcode::F128const = v1231 {
                                                                    let v1233 = C::ieee128_constant_extractor(ctx, v1232);
                                                                    if let Some(v1234) = v1233 {
                                                                        let v1257 = C::f128_max(ctx, v1234, v1238);
                                                                        if let Some(v1258) = v1257 {
                                                                            let v1259 = C::ieee128_constant(ctx, v1258);
                                                                            let v1260 = constructor_f128const(ctx, F128, v1259);
                                                                            let v1261 = C::subsume(ctx, v1260);
                                                                            // Rule at src/opts/cprop.isle line 463.
                                                                            returns.extend(Some(v1261));
                                                                            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 v138,
                                        args: ref v139,
                                    } => {
                                        if let &Opcode::Sshr = v138 {
                                            let v140 = C::unpack_value_array_2(ctx, v139);
                                            if v7.0 == v140.0 {
                                                let mut v414 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v140.1, &mut v414);
                                                let mut v414 = v414.into_context_iter();
                                                while let Some(v415) = v414.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v1097,
                                                        imm: v1098,
                                                    } = &v415.1 {
                                                        if let &Opcode::Iconst = v1097 {
                                                            let v1367 = C::u64_from_imm64(ctx, v1098);
                                                            if v1367 == 0x3f_u64 {
                                                                let v1368 = constructor_sextend(ctx, I128, v7.0);
                                                                // Rule at src/opts/extends.isle line 94.
                                                                returns.extend(Some(v1368));
                                                                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 v1366 = constructor_uextend(ctx, I128, v7.0);
                                                // Rule at src/opts/extends.isle line 93.
                                                returns.extend(Some(v1366));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                        }
                    }
                    _ => {}
                }
            }
            &InstructionData::IntCompare {
                opcode: ref v152,
                args: ref v153,
                cond: ref v154,
            } => {
                if let &Opcode::Icmp = v152 {
                    match v154 {
                        &IntCC::Equal => {
                            let v155 = C::unpack_value_array_2(ctx, v153);
                            let mut v158 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v155.0, &mut v158);
                            let mut v158 = v158.into_context_iter();
                            while let Some(v159) = v158.next(ctx) {
                                match &v159.1 {
                                    &InstructionData::Binary {
                                        opcode: ref v203,
                                        args: ref v204,
                                    } => {
                                        match v203 {
                                            &Opcode::Iadd => {
                                                let mut v165 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v155.1, &mut v165);
                                                let mut v165 = v165.into_context_iter();
                                                while let Some(v166) = v165.next(ctx) {
                                                    match &v166.1 {
                                                        &InstructionData::Binary {
                                                            opcode: ref v169,
                                                            args: ref v170,
                                                        } => {
                                                            if let &Opcode::Iadd = v169 {
                                                                let v171 = C::unpack_value_array_2(ctx, v170);
                                                                let v205 = C::unpack_value_array_2(ctx, v204);
                                                                if v171.0 == v205.0 {
                                                                    let v717 = constructor_eq(ctx, v2.0, v205.1, v171.1);
                                                                    let v1374 = C::subsume(ctx, v717);
                                                                    // Rule at src/opts/icmp.isle line 26.
                                                                    returns.extend(Some(v1374));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v171.0 == v205.1 {
                                                                    let v713 = constructor_eq(ctx, v2.0, v205.0, v171.1);
                                                                    let v1372 = C::subsume(ctx, v713);
                                                                    // Rule at src/opts/icmp.isle line 22.
                                                                    returns.extend(Some(v1372));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v171.1 == v205.0 {
                                                                    let v715 = constructor_eq(ctx, v2.0, v205.1, v171.0);
                                                                    let v1373 = C::subsume(ctx, v715);
                                                                    // Rule at src/opts/icmp.isle line 24.
                                                                    returns.extend(Some(v1373));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v171.1 == v205.1 {
                                                                    let v711 = constructor_eq(ctx, v2.0, v205.0, v171.0);
                                                                    let v1371 = C::subsume(ctx, v711);
                                                                    // Rule at src/opts/icmp.isle line 20.
                                                                    returns.extend(Some(v1371));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                let mut v174 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v171.1, &mut v174);
                                                                let mut v174 = v174.into_context_iter();
                                                                while let Some(v175) = v174.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v178,
                                                                        imm: v179,
                                                                    } = &v175.1 {
                                                                        if let &Opcode::Iconst = v178 {
                                                                            let mut v208 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v205.1, &mut v208);
                                                                            let mut v208 = v208.into_context_iter();
                                                                            while let Some(v209) = v208.next(ctx) {
                                                                                if let &InstructionData::UnaryImm {
                                                                                    opcode: ref v212,
                                                                                    imm: v213,
                                                                                } = &v209.1 {
                                                                                    if let &Opcode::Iconst = v212 {
                                                                                        let v1051 = constructor_isub(ctx, v166.0, v171.1, v205.1);
                                                                                        let v1052 = constructor_iadd(ctx, v159.0, v171.0, v1051);
                                                                                        let v1053 = constructor_eq(ctx, v2.0, v205.0, v1052);
                                                                                        // Rule at src/opts/cprop.isle line 256.
                                                                                        returns.extend(Some(v1053));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::UnaryImm {
                                                            opcode: ref v215,
                                                            imm: v216,
                                                        } => {
                                                            if let &Opcode::Iconst = v215 {
                                                                let v205 = C::unpack_value_array_2(ctx, v204);
                                                                let mut v208 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v205.1, &mut v208);
                                                                let mut v208 = v208.into_context_iter();
                                                                while let Some(v209) = v208.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v212,
                                                                        imm: v213,
                                                                    } = &v209.1 {
                                                                        if let &Opcode::Iconst = v212 {
                                                                            let v1045 = constructor_isub(ctx, v159.0, v155.1, v205.1);
                                                                            let v1046 = constructor_eq(ctx, v2.0, v205.0, v1045);
                                                                            // Rule at src/opts/cprop.isle line 246.
                                                                            returns.extend(Some(v1046));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let v205 = C::unpack_value_array_2(ctx, v204);
                                                if v155.1 == v205.0 {
                                                    let v250 = constructor_iconst_u(ctx, v159.0, 0x0_u64);
                                                    let v251 = constructor_eq(ctx, v2.0, v205.1, v250);
                                                    // Rule at src/opts/arithmetic.isle line 329.
                                                    returns.extend(Some(v251));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v155.1 == v205.1 {
                                                    let v250 = constructor_iconst_u(ctx, v159.0, 0x0_u64);
                                                    let v254 = constructor_eq(ctx, v2.0, v205.0, v250);
                                                    // Rule at src/opts/arithmetic.isle line 328.
                                                    returns.extend(Some(v254));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                            &Opcode::Isub => {
                                                let v205 = C::unpack_value_array_2(ctx, v204);
                                                let mut v208 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v205.1, &mut v208);
                                                let mut v208 = v208.into_context_iter();
                                                while let Some(v209) = v208.next(ctx) {
                                                    match &v209.1 {
                                                        &InstructionData::IntCompare {
                                                            opcode: ref v1933,
                                                            args: ref v1934,
                                                            cond: ref v1935,
                                                        } => {
                                                            if let &Opcode::Icmp = v1933 {
                                                                match v1935 {
                                                                    &IntCC::SignedLessThan => {
                                                                        if v159.0 == I8 {
                                                                            let mut v225 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v205.0, &mut v225);
                                                                            let mut v225 = v225.into_context_iter();
                                                                            while let Some(v226) = v225.next(ctx) {
                                                                                if let &InstructionData::IntCompare {
                                                                                    opcode: ref v1927,
                                                                                    args: ref v1928,
                                                                                    cond: ref v1929,
                                                                                } = &v226.1 {
                                                                                    if let &Opcode::Icmp = v1927 {
                                                                                        if let &IntCC::SignedGreaterThan = v1929 {
                                                                                            if v209.0 == v226.0 {
                                                                                                let v1930 = C::unpack_value_array_2(ctx, v1928);
                                                                                                let v1936 = C::unpack_value_array_2(ctx, v1934);
                                                                                                if v1930.0 == v1936.0 {
                                                                                                    if v1930.1 == v1936.1 {
                                                                                                        let mut v1326 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                        C::inst_data_value_tupled_etor(ctx, v155.1, &mut v1326);
                                                                                                        let mut v1326 = v1326.into_context_iter();
                                                                                                        while let Some(v1327) = v1326.next(ctx) {
                                                                                                            let v1328 = C::iconst_sextend_etor(ctx, v1327);
                                                                                                            if let Some(v1329) = v1328 {
                                                                                                                match v1329.1 {
                                                                                                                    -1_i64 => {
                                                                                                                        let v1941 = constructor_slt(ctx, v226.0, v1930.0, v1930.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 178.
                                                                                                                        returns.extend(Some(v1941));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                    0_i64 => {
                                                                                                                        let v1939 = constructor_eq(ctx, v226.0, v1930.0, v1930.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 145.
                                                                                                                        returns.extend(Some(v1939));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                    1_i64 => {
                                                                                                                        let v1945 = constructor_sgt(ctx, v226.0, v1930.0, v1930.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 186.
                                                                                                                        returns.extend(Some(v1945));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                    _ => {}
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        if v159.0 == I8 {
                                                                            let mut v225 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v205.0, &mut v225);
                                                                            let mut v225 = v225.into_context_iter();
                                                                            while let Some(v226) = v225.next(ctx) {
                                                                                if let &InstructionData::IntCompare {
                                                                                    opcode: ref v1927,
                                                                                    args: ref v1928,
                                                                                    cond: ref v1929,
                                                                                } = &v226.1 {
                                                                                    if let &Opcode::Icmp = v1927 {
                                                                                        if let &IntCC::UnsignedGreaterThan = v1929 {
                                                                                            if v209.0 == v226.0 {
                                                                                                let v1930 = C::unpack_value_array_2(ctx, v1928);
                                                                                                let v1936 = C::unpack_value_array_2(ctx, v1934);
                                                                                                if v1930.0 == v1936.0 {
                                                                                                    if v1930.1 == v1936.1 {
                                                                                                        let mut v1326 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                        C::inst_data_value_tupled_etor(ctx, v155.1, &mut v1326);
                                                                                                        let mut v1326 = v1326.into_context_iter();
                                                                                                        while let Some(v1327) = v1326.next(ctx) {
                                                                                                            let v1328 = C::iconst_sextend_etor(ctx, v1327);
                                                                                                            if let Some(v1329) = v1328 {
                                                                                                                match v1329.1 {
                                                                                                                    -1_i64 => {
                                                                                                                        let v1942 = constructor_ult(ctx, v226.0, v1930.0, v1930.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 180.
                                                                                                                        returns.extend(Some(v1942));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                    0_i64 => {
                                                                                                                        let v1939 = constructor_eq(ctx, v226.0, v1930.0, v1930.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 147.
                                                                                                                        returns.extend(Some(v1939));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                    1_i64 => {
                                                                                                                        let v1946 = constructor_ugt(ctx, v226.0, v1930.0, v1930.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 188.
                                                                                                                        returns.extend(Some(v1946));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                    _ => {}
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::UnaryImm {
                                                            opcode: ref v212,
                                                            imm: v213,
                                                        } => {
                                                            if let &Opcode::Iconst = v212 {
                                                                let mut v165 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v155.1, &mut v165);
                                                                let mut v165 = v165.into_context_iter();
                                                                while let Some(v166) = v165.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v215,
                                                                        imm: v216,
                                                                    } = &v166.1 {
                                                                        if let &Opcode::Iconst = v215 {
                                                                            let v1048 = constructor_iadd(ctx, v159.0, v155.1, v205.1);
                                                                            let v1049 = constructor_eq(ctx, v2.0, v205.0, v1048);
                                                                            // Rule at src/opts/cprop.isle line 251.
                                                                            returns.extend(Some(v1049));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                if v155.1 == v205.0 {
                                                    let v250 = constructor_iconst_u(ctx, v159.0, 0x0_u64);
                                                    let v251 = constructor_eq(ctx, v2.0, v205.1, v250);
                                                    // Rule at src/opts/arithmetic.isle line 324.
                                                    returns.extend(Some(v251));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let mut v165 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v155.1, &mut v165);
                                                let mut v165 = v165.into_context_iter();
                                                while let Some(v166) = v165.next(ctx) {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v169,
                                                        args: ref v170,
                                                    } = &v166.1 {
                                                        if let &Opcode::Isub = v169 {
                                                            let v171 = C::unpack_value_array_2(ctx, v170);
                                                            let v1379 = constructor_iadd(ctx, v159.0, v205.0, v171.1);
                                                            let v1380 = constructor_iadd(ctx, v166.0, v171.0, v205.1);
                                                            let v1381 = constructor_eq(ctx, v2.0, v1379, v1380);
                                                            // Rule at src/opts/icmp.isle line 40.
                                                            returns.extend(Some(v1381));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                            }
                                            &Opcode::Imul => {
                                                let mut v165 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v155.1, &mut v165);
                                                let mut v165 = v165.into_context_iter();
                                                while let Some(v166) = v165.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v215,
                                                        imm: v216,
                                                    } = &v166.1 {
                                                        if let &Opcode::Iconst = v215 {
                                                            if v159.0 == v166.0 {
                                                                let v205 = C::unpack_value_array_2(ctx, v204);
                                                                let mut v208 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v205.1, &mut v208);
                                                                let mut v208 = v208.into_context_iter();
                                                                while let Some(v209) = v208.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v212,
                                                                        imm: v213,
                                                                    } = &v209.1 {
                                                                        if let &Opcode::Iconst = v212 {
                                                                            let v217 = C::u64_from_imm64(ctx, v216);
                                                                            let v214 = C::u64_from_imm64(ctx, v213);
                                                                            let v218 = C::u64_checked_rem(ctx, v217, v214);
                                                                            if let Some(v219) = v218 {
                                                                                if v219 == 0x0_u64 {
                                                                                    let v220 = C::u64_rem(ctx, v214, 0x2_u64);
                                                                                    if v220 == 0x1_u64 {
                                                                                        if v159.0 == v209.0 {
                                                                                            let v221 = C::u64_div(ctx, v217, v214);
                                                                                            let v222 = C::imm64(ctx, v221);
                                                                                            let v223 = constructor_iconst(ctx, v159.0, v222);
                                                                                            let v241 = constructor_eq(ctx, v2.0, v205.0, v223);
                                                                                            // Rule at src/opts/arithmetic.isle line 284.
                                                                                            returns.extend(Some(v241));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                let mut v225 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v205.0, &mut v225);
                                                                let mut v225 = v225.into_context_iter();
                                                                while let Some(v226) = v225.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v229,
                                                                        imm: v230,
                                                                    } = &v226.1 {
                                                                        if let &Opcode::Iconst = v229 {
                                                                            let v217 = C::u64_from_imm64(ctx, v216);
                                                                            let v231 = C::u64_from_imm64(ctx, v230);
                                                                            let v232 = C::u64_checked_rem(ctx, v217, v231);
                                                                            if let Some(v233) = v232 {
                                                                                if v233 == 0x0_u64 {
                                                                                    let v234 = C::u64_rem(ctx, v231, 0x2_u64);
                                                                                    if v234 == 0x1_u64 {
                                                                                        if v159.0 == v226.0 {
                                                                                            let v235 = C::u64_div(ctx, v217, v231);
                                                                                            let v236 = C::imm64(ctx, v235);
                                                                                            let v237 = constructor_iconst(ctx, v159.0, v236);
                                                                                            let v242 = constructor_eq(ctx, v2.0, v205.1, v237);
                                                                                            // Rule at src/opts/arithmetic.isle line 289.
                                                                                            returns.extend(Some(v242));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            &Opcode::Band => {
                                                let mut v165 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v155.1, &mut v165);
                                                let mut v165 = v165.into_context_iter();
                                                while let Some(v166) = v165.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v258,
                                                        arg: v259,
                                                    } = &v166.1 {
                                                        if let &Opcode::Bnot = v258 {
                                                            if v159.0 == v166.0 {
                                                                let v205 = C::unpack_value_array_2(ctx, v204);
                                                                let mut v208 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v205.1, &mut v208);
                                                                let mut v208 = v208.into_context_iter();
                                                                while let Some(v209) = v208.next(ctx) {
                                                                    if let &InstructionData::Unary {
                                                                        opcode: ref v905,
                                                                        arg: v906,
                                                                    } = &v209.1 {
                                                                        if let &Opcode::Bnot = v905 {
                                                                            if v259 == v906 {
                                                                                if v159.0 == v209.0 {
                                                                                    let v907 = constructor_bor(ctx, v159.0, v906, v205.0);
                                                                                    let v903 = constructor_iconst_s(ctx, v159.0, -1_i64);
                                                                                    let v908 = constructor_eq(ctx, v2.0, v907, v903);
                                                                                    // Rule at src/opts/bitops.isle line 656.
                                                                                    returns.extend(Some(v908));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                let mut v225 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v205.0, &mut v225);
                                                                let mut v225 = v225.into_context_iter();
                                                                while let Some(v226) = v225.next(ctx) {
                                                                    if let &InstructionData::Unary {
                                                                        opcode: ref v900,
                                                                        arg: v901,
                                                                    } = &v226.1 {
                                                                        if let &Opcode::Bnot = v900 {
                                                                            if v259 == v901 {
                                                                                if v159.0 == v226.0 {
                                                                                    let v902 = constructor_bor(ctx, v159.0, v901, v205.1);
                                                                                    let v903 = constructor_iconst_s(ctx, v159.0, -1_i64);
                                                                                    let v904 = constructor_eq(ctx, v2.0, v902, v903);
                                                                                    // Rule at src/opts/bitops.isle line 655.
                                                                                    returns.extend(Some(v904));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            &Opcode::Bxor => {
                                                let mut v165 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v155.1, &mut v165);
                                                let mut v165 = v165.into_context_iter();
                                                while let Some(v166) = v165.next(ctx) {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v169,
                                                        args: ref v170,
                                                    } = &v166.1 {
                                                        if let &Opcode::Bxor = v169 {
                                                            if v159.0 == v166.0 {
                                                                let v171 = C::unpack_value_array_2(ctx, v170);
                                                                let v205 = C::unpack_value_array_2(ctx, v204);
                                                                if v171.0 == v205.0 {
                                                                    let v717 = constructor_eq(ctx, v2.0, v205.1, v171.1);
                                                                    // Rule at src/opts/bitops.isle line 309.
                                                                    returns.extend(Some(v717));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    let v718 = constructor_eq(ctx, v2.0, v171.1, v205.1);
                                                                    // Rule at src/opts/bitops.isle line 310.
                                                                    returns.extend(Some(v718));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v171.0 == v205.1 {
                                                                    let v713 = constructor_eq(ctx, v2.0, v205.0, v171.1);
                                                                    // Rule at src/opts/bitops.isle line 305.
                                                                    returns.extend(Some(v713));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    let v716 = constructor_eq(ctx, v2.0, v171.1, v205.0);
                                                                    // Rule at src/opts/bitops.isle line 308.
                                                                    returns.extend(Some(v716));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v171.1 == v205.0 {
                                                                    let v714 = constructor_eq(ctx, v2.0, v171.0, v205.1);
                                                                    // Rule at src/opts/bitops.isle line 306.
                                                                    returns.extend(Some(v714));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    let v715 = constructor_eq(ctx, v2.0, v205.1, v171.0);
                                                                    // Rule at src/opts/bitops.isle line 307.
                                                                    returns.extend(Some(v715));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v171.1 == v205.1 {
                                                                    let v711 = constructor_eq(ctx, v2.0, v205.0, v171.0);
                                                                    // Rule at src/opts/bitops.isle line 303.
                                                                    returns.extend(Some(v711));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    let v712 = constructor_eq(ctx, v2.0, v171.0, v205.0);
                                                                    // Rule at src/opts/bitops.isle line 304.
                                                                    returns.extend(Some(v712));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                    &InstructionData::Ternary {
                                        opcode: ref v1499,
                                        args: ref v1500,
                                    } => {
                                        if let &Opcode::Select = v1499 {
                                            let mut v165 = C::inst_data_value_etor_returns::default();
                                            C::inst_data_value_etor(ctx, v155.1, &mut v165);
                                            let mut v165 = v165.into_context_iter();
                                            while let Some(v166) = v165.next(ctx) {
                                                if let &InstructionData::UnaryImm {
                                                    opcode: ref v215,
                                                    imm: v216,
                                                } = &v166.1 {
                                                    if let &Opcode::Iconst = v215 {
                                                        let v1501 = C::unpack_value_array_3(ctx, v1500);
                                                        let mut v1554 = C::inst_data_value_etor_returns::default();
                                                        C::inst_data_value_etor(ctx, v1501.1, &mut v1554);
                                                        let mut v1554 = v1554.into_context_iter();
                                                        while let Some(v1555) = v1554.next(ctx) {
                                                            if let &InstructionData::UnaryImm {
                                                                opcode: ref v1558,
                                                                imm: v1559,
                                                            } = &v1555.1 {
                                                                if let &Opcode::Iconst = v1558 {
                                                                    let mut v1561 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v1501.2, &mut v1561);
                                                                    let mut v1561 = v1561.into_context_iter();
                                                                    while let Some(v1562) = v1561.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v1565,
                                                                            imm: v1566,
                                                                        } = &v1562.1 {
                                                                            if let &Opcode::Iconst = v1565 {
                                                                                let v1560 = C::u64_from_imm64(ctx, v1559);
                                                                                let v1567 = C::u64_from_imm64(ctx, v1566);
                                                                                let v1568 = C::u64_eq(ctx, v1560, v1567);
                                                                                if v1568 == false {
                                                                                    let v217 = C::u64_from_imm64(ctx, v216);
                                                                                    if v217 == v1560 {
                                                                                        let v1553 = C::value_type(ctx, v1501.0);
                                                                                        let v1569 = constructor_iconst_u(ctx, v1553, 0x0_u64);
                                                                                        let v1570 = constructor_ne(ctx, v159.0, v1501.0, v1569);
                                                                                        // Rule at src/opts/icmp.isle line 385.
                                                                                        returns.extend(Some(v1570));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v217 == v1567 {
                                                                                        let v1553 = C::value_type(ctx, v1501.0);
                                                                                        let v1569 = constructor_iconst_u(ctx, v1553, 0x0_u64);
                                                                                        let v1571 = constructor_eq(ctx, v159.0, v1501.0, v1569);
                                                                                        // Rule at src/opts/icmp.isle line 393.
                                                                                        returns.extend(Some(v1571));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    &InstructionData::Unary {
                                        opcode: ref v256,
                                        arg: v257,
                                    } => {
                                        match v256 {
                                            &Opcode::Ineg => {
                                                if v2.0 == v159.0 {
                                                    let mut v165 = C::inst_data_value_etor_returns::default();
                                                    C::inst_data_value_etor(ctx, v155.1, &mut v165);
                                                    let mut v165 = v165.into_context_iter();
                                                    while let Some(v166) = v165.next(ctx) {
                                                        if let &InstructionData::Unary {
                                                            opcode: ref v258,
                                                            arg: v259,
                                                        } = &v166.1 {
                                                            if let &Opcode::Ineg = v258 {
                                                                if v2.0 == v166.0 {
                                                                    let v260 = constructor_eq(ctx, v2.0, v257, v259);
                                                                    // Rule at src/opts/arithmetic.isle line 334.
                                                                    returns.extend(Some(v260));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            &Opcode::Bnot => {
                                                let mut v165 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v155.1, &mut v165);
                                                let mut v165 = v165.into_context_iter();
                                                while let Some(v166) = v165.next(ctx) {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v169,
                                                        args: ref v170,
                                                    } = &v166.1 {
                                                        if let &Opcode::Band = v169 {
                                                            if v159.0 == v166.0 {
                                                                let v171 = C::unpack_value_array_2(ctx, v170);
                                                                let mut v174 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v171.1, &mut v174);
                                                                let mut v174 = v174.into_context_iter();
                                                                while let Some(v175) = v174.next(ctx) {
                                                                    if let &InstructionData::Unary {
                                                                        opcode: ref v913,
                                                                        arg: v914,
                                                                    } = &v175.1 {
                                                                        if let &Opcode::Bnot = v913 {
                                                                            if v257 == v914 {
                                                                                if v159.0 == v175.0 {
                                                                                    let v915 = constructor_bor(ctx, v159.0, v257, v171.0);
                                                                                    let v903 = constructor_iconst_s(ctx, v159.0, -1_i64);
                                                                                    let v916 = constructor_eq(ctx, v2.0, v915, v903);
                                                                                    // Rule at src/opts/bitops.isle line 658.
                                                                                    returns.extend(Some(v916));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                let mut v189 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v171.0, &mut v189);
                                                                let mut v189 = v189.into_context_iter();
                                                                while let Some(v190) = v189.next(ctx) {
                                                                    if let &InstructionData::Unary {
                                                                        opcode: ref v909,
                                                                        arg: v910,
                                                                    } = &v190.1 {
                                                                        if let &Opcode::Bnot = v909 {
                                                                            if v257 == v910 {
                                                                                if v159.0 == v190.0 {
                                                                                    let v911 = constructor_bor(ctx, v159.0, v257, v171.1);
                                                                                    let v903 = constructor_iconst_s(ctx, v159.0, -1_i64);
                                                                                    let v912 = constructor_eq(ctx, v2.0, v911, v903);
                                                                                    // Rule at src/opts/bitops.isle line 657.
                                                                                    returns.extend(Some(v912));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            &Opcode::Sextend => {
                                                let mut v1326 = C::inst_data_value_tupled_etor_returns::default();
                                                C::inst_data_value_tupled_etor(ctx, v155.1, &mut v1326);
                                                let mut v1326 = v1326.into_context_iter();
                                                while let Some(v1327) = v1326.next(ctx) {
                                                    let v1328 = C::iconst_sextend_etor(ctx, v1327);
                                                    if let Some(v1329) = v1328 {
                                                        if v1329.1 == 0_i64 {
                                                            let v1322 = C::value_type(ctx, v257);
                                                            let v1333 = constructor_iconst_s(ctx, v1322, 0_i64);
                                                            let v1334 = constructor_eq(ctx, v1322, v257, v1333);
                                                            // Rule at src/opts/extends.isle line 39.
                                                            returns.extend(Some(v1334));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                    &InstructionData::UnaryImm {
                                        opcode: ref v162,
                                        imm: v163,
                                    } => {
                                        if let &Opcode::Iconst = v162 {
                                            let mut v165 = C::inst_data_value_etor_returns::default();
                                            C::inst_data_value_etor(ctx, v155.1, &mut v165);
                                            let mut v165 = v165.into_context_iter();
                                            while let Some(v166) = v165.next(ctx) {
                                                if let &InstructionData::Binary {
                                                    opcode: ref v169,
                                                    args: ref v170,
                                                } = &v166.1 {
                                                    if let &Opcode::Imul = v169 {
                                                        if v159.0 == v166.0 {
                                                            let v171 = C::unpack_value_array_2(ctx, v170);
                                                            let mut v174 = C::inst_data_value_etor_returns::default();
                                                            C::inst_data_value_etor(ctx, v171.1, &mut v174);
                                                            let mut v174 = v174.into_context_iter();
                                                            while let Some(v175) = v174.next(ctx) {
                                                                if let &InstructionData::UnaryImm {
                                                                    opcode: ref v178,
                                                                    imm: v179,
                                                                } = &v175.1 {
                                                                    if let &Opcode::Iconst = v178 {
                                                                        let v164 = C::u64_from_imm64(ctx, v163);
                                                                        let v180 = C::u64_from_imm64(ctx, v179);
                                                                        let v181 = C::u64_checked_rem(ctx, v164, v180);
                                                                        if let Some(v182) = v181 {
                                                                            if v182 == 0x0_u64 {
                                                                                let v184 = C::u64_rem(ctx, v180, 0x2_u64);
                                                                                if v184 == 0x1_u64 {
                                                                                    if v159.0 == v175.0 {
                                                                                        let v185 = C::u64_div(ctx, v164, v180);
                                                                                        let v186 = C::imm64(ctx, v185);
                                                                                        let v187 = constructor_iconst(ctx, v159.0, v186);
                                                                                        let v239 = constructor_eq(ctx, v2.0, v171.0, v187);
                                                                                        // Rule at src/opts/arithmetic.isle line 274.
                                                                                        returns.extend(Some(v239));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            let mut v189 = C::inst_data_value_etor_returns::default();
                                                            C::inst_data_value_etor(ctx, v171.0, &mut v189);
                                                            let mut v189 = v189.into_context_iter();
                                                            while let Some(v190) = v189.next(ctx) {
                                                                if let &InstructionData::UnaryImm {
                                                                    opcode: ref v193,
                                                                    imm: v194,
                                                                } = &v190.1 {
                                                                    if let &Opcode::Iconst = v193 {
                                                                        let v164 = C::u64_from_imm64(ctx, v163);
                                                                        let v195 = C::u64_from_imm64(ctx, v194);
                                                                        let v196 = C::u64_checked_rem(ctx, v164, v195);
                                                                        if let Some(v197) = v196 {
                                                                            if v197 == 0x0_u64 {
                                                                                let v198 = C::u64_rem(ctx, v195, 0x2_u64);
                                                                                if v198 == 0x1_u64 {
                                                                                    if v159.0 == v190.0 {
                                                                                        let v199 = C::u64_div(ctx, v164, v195);
                                                                                        let v200 = C::imm64(ctx, v199);
                                                                                        let v201 = constructor_iconst(ctx, v159.0, v200);
                                                                                        let v240 = constructor_eq(ctx, v2.0, v171.1, v201);
                                                                                        // Rule at src/opts/arithmetic.isle line 279.
                                                                                        returns.extend(Some(v240));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                            let mut v165 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v155.1, &mut v165);
                            let mut v165 = v165.into_context_iter();
                            while let Some(v166) = v165.next(ctx) {
                                match &v166.1 {
                                    &InstructionData::Binary {
                                        opcode: ref v169,
                                        args: ref v170,
                                    } => {
                                        match v169 {
                                            &Opcode::Iadd => {
                                                let v171 = C::unpack_value_array_2(ctx, v170);
                                                if v155.0 == v171.0 {
                                                    let v252 = constructor_iconst_u(ctx, v166.0, 0x0_u64);
                                                    let v253 = constructor_eq(ctx, v2.0, v171.1, v252);
                                                    // Rule at src/opts/arithmetic.isle line 331.
                                                    returns.extend(Some(v253));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v155.0 == v171.1 {
                                                    let v252 = constructor_iconst_u(ctx, v166.0, 0x0_u64);
                                                    let v255 = constructor_eq(ctx, v2.0, v171.0, v252);
                                                    // Rule at src/opts/arithmetic.isle line 330.
                                                    returns.extend(Some(v255));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                            &Opcode::Isub => {
                                                let v171 = C::unpack_value_array_2(ctx, v170);
                                                if v155.0 == v171.0 {
                                                    let v252 = constructor_iconst_u(ctx, v166.0, 0x0_u64);
                                                    let v253 = constructor_eq(ctx, v2.0, v171.1, v252);
                                                    // Rule at src/opts/arithmetic.isle line 325.
                                                    returns.extend(Some(v253));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                            &Opcode::Bxor => {
                                                let v1490 = C::ty_int(ctx, v166.0);
                                                if let Some(v1491) = v1490 {
                                                    let v171 = C::unpack_value_array_2(ctx, v170);
                                                    if v155.0 == v171.0 {
                                                        let v1492 = constructor_iconst_u(ctx, v1491, 0x0_u64);
                                                        let v1493 = constructor_eq(ctx, v2.0, v171.1, v1492);
                                                        let v1494 = C::subsume(ctx, v1493);
                                                        // Rule at src/opts/icmp.isle line 294.
                                                        returns.extend(Some(v1494));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                    &InstructionData::UnaryImm {
                                        opcode: ref v215,
                                        imm: v216,
                                    } => {
                                        if let &Opcode::Iconst = v215 {
                                            let v217 = C::u64_from_imm64(ctx, v216);
                                            match v217 {
                                                0x0_u64 => {
                                                    let mut v1383 = C::uextend_maybe_etor_returns::default();
                                                    C::uextend_maybe_etor(ctx, v155.0, &mut v1383);
                                                    let mut v1383 = v1383.into_context_iter();
                                                    while let Some(v1384) = v1383.next(ctx) {
                                                        let mut v1387 = C::inst_data_value_etor_returns::default();
                                                        C::inst_data_value_etor(ctx, v1384.1, &mut v1387);
                                                        let mut v1387 = v1387.into_context_iter();
                                                        while let Some(v1388) = v1387.next(ctx) {
                                                            if let &InstructionData::IntCompare {
                                                                opcode: ref v1391,
                                                                args: ref v1392,
                                                                cond: ref v1393,
                                                            } = &v1388.1 {
                                                                if let &Opcode::Icmp = v1391 {
                                                                    if v2.0 == v1388.0 {
                                                                        let v1404 = &C::intcc_complement(ctx, v1393);
                                                                        let v1394 = C::unpack_value_array_2(ctx, v1392);
                                                                        let v1405 = constructor_icmp(ctx, v2.0, v1404, v1394.0, v1394.1);
                                                                        let v1406 = C::subsume(ctx, v1405);
                                                                        // Rule at src/opts/icmp.isle line 62.
                                                                        returns.extend(Some(v1406));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                0x1_u64 => {
                                                    let mut v1383 = C::uextend_maybe_etor_returns::default();
                                                    C::uextend_maybe_etor(ctx, v155.0, &mut v1383);
                                                    let mut v1383 = v1383.into_context_iter();
                                                    while let Some(v1384) = v1383.next(ctx) {
                                                        let mut v1387 = C::inst_data_value_etor_returns::default();
                                                        C::inst_data_value_etor(ctx, v1384.1, &mut v1387);
                                                        let mut v1387 = v1387.into_context_iter();
                                                        while let Some(v1388) = v1387.next(ctx) {
                                                            if let &InstructionData::IntCompare {
                                                                opcode: ref v1391,
                                                                args: ref v1392,
                                                                cond: ref v1393,
                                                            } = &v1388.1 {
                                                                if let &Opcode::Icmp = v1391 {
                                                                    let v1397 = C::subsume(ctx, v1384.1);
                                                                    // Rule at src/opts/icmp.isle line 76.
                                                                    returns.extend(Some(v1397));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                _ => {}
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                            if v155.0 == v155.1 {
                                let v297 = C::ty_int(ctx, v2.0);
                                if let Some(v298) = v297 {
                                    let v1369 = constructor_iconst_u(ctx, v298, 0x1_u64);
                                    let v1370 = C::subsume(ctx, v1369);
                                    // Rule at src/opts/icmp.isle line 4.
                                    returns.extend(Some(v1370));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                        }
                        &IntCC::NotEqual => {
                            let v155 = C::unpack_value_array_2(ctx, v153);
                            let mut v158 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v155.0, &mut v158);
                            let mut v158 = v158.into_context_iter();
                            while let Some(v159) = v158.next(ctx) {
                                match &v159.1 {
                                    &InstructionData::Binary {
                                        opcode: ref v203,
                                        args: ref v204,
                                    } => {
                                        match v203 {
                                            &Opcode::Iadd => {
                                                let mut v165 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v155.1, &mut v165);
                                                let mut v165 = v165.into_context_iter();
                                                while let Some(v166) = v165.next(ctx) {
                                                    match &v166.1 {
                                                        &InstructionData::Binary {
                                                            opcode: ref v169,
                                                            args: ref v170,
                                                        } => {
                                                            if let &Opcode::Iadd = v169 {
                                                                let v171 = C::unpack_value_array_2(ctx, v170);
                                                                let v205 = C::unpack_value_array_2(ctx, v204);
                                                                if v171.0 == v205.0 {
                                                                    let v809 = constructor_ne(ctx, v2.0, v205.1, v171.1);
                                                                    let v1378 = C::subsume(ctx, v809);
                                                                    // Rule at src/opts/icmp.isle line 34.
                                                                    returns.extend(Some(v1378));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v171.0 == v205.1 {
                                                                    let v805 = constructor_ne(ctx, v2.0, v205.0, v171.1);
                                                                    let v1376 = C::subsume(ctx, v805);
                                                                    // Rule at src/opts/icmp.isle line 30.
                                                                    returns.extend(Some(v1376));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v171.1 == v205.0 {
                                                                    let v807 = constructor_ne(ctx, v2.0, v205.1, v171.0);
                                                                    let v1377 = C::subsume(ctx, v807);
                                                                    // Rule at src/opts/icmp.isle line 32.
                                                                    returns.extend(Some(v1377));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v171.1 == v205.1 {
                                                                    let v803 = constructor_ne(ctx, v2.0, v205.0, v171.0);
                                                                    let v1375 = C::subsume(ctx, v803);
                                                                    // Rule at src/opts/icmp.isle line 28.
                                                                    returns.extend(Some(v1375));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                let mut v174 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v171.1, &mut v174);
                                                                let mut v174 = v174.into_context_iter();
                                                                while let Some(v175) = v174.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v178,
                                                                        imm: v179,
                                                                    } = &v175.1 {
                                                                        if let &Opcode::Iconst = v178 {
                                                                            let mut v208 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v205.1, &mut v208);
                                                                            let mut v208 = v208.into_context_iter();
                                                                            while let Some(v209) = v208.next(ctx) {
                                                                                if let &InstructionData::UnaryImm {
                                                                                    opcode: ref v212,
                                                                                    imm: v213,
                                                                                } = &v209.1 {
                                                                                    if let &Opcode::Iconst = v212 {
                                                                                        let v1051 = constructor_isub(ctx, v166.0, v171.1, v205.1);
                                                                                        let v1052 = constructor_iadd(ctx, v159.0, v171.0, v1051);
                                                                                        let v1054 = constructor_ne(ctx, v2.0, v205.0, v1052);
                                                                                        // Rule at src/opts/cprop.isle line 258.
                                                                                        returns.extend(Some(v1054));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::UnaryImm {
                                                            opcode: ref v215,
                                                            imm: v216,
                                                        } => {
                                                            if let &Opcode::Iconst = v215 {
                                                                let v205 = C::unpack_value_array_2(ctx, v204);
                                                                let mut v208 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v205.1, &mut v208);
                                                                let mut v208 = v208.into_context_iter();
                                                                while let Some(v209) = v208.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v212,
                                                                        imm: v213,
                                                                    } = &v209.1 {
                                                                        if let &Opcode::Iconst = v212 {
                                                                            let v1045 = constructor_isub(ctx, v159.0, v155.1, v205.1);
                                                                            let v1047 = constructor_ne(ctx, v2.0, v205.0, v1045);
                                                                            // Rule at src/opts/cprop.isle line 248.
                                                                            returns.extend(Some(v1047));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                            }
                                            &Opcode::Isub => {
                                                let v205 = C::unpack_value_array_2(ctx, v204);
                                                let mut v208 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v205.1, &mut v208);
                                                let mut v208 = v208.into_context_iter();
                                                while let Some(v209) = v208.next(ctx) {
                                                    match &v209.1 {
                                                        &InstructionData::IntCompare {
                                                            opcode: ref v1933,
                                                            args: ref v1934,
                                                            cond: ref v1935,
                                                        } => {
                                                            if let &Opcode::Icmp = v1933 {
                                                                match v1935 {
                                                                    &IntCC::SignedLessThan => {
                                                                        if v159.0 == I8 {
                                                                            let mut v225 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v205.0, &mut v225);
                                                                            let mut v225 = v225.into_context_iter();
                                                                            while let Some(v226) = v225.next(ctx) {
                                                                                if let &InstructionData::IntCompare {
                                                                                    opcode: ref v1927,
                                                                                    args: ref v1928,
                                                                                    cond: ref v1929,
                                                                                } = &v226.1 {
                                                                                    if let &Opcode::Icmp = v1927 {
                                                                                        if let &IntCC::SignedGreaterThan = v1929 {
                                                                                            if v209.0 == v226.0 {
                                                                                                let v1930 = C::unpack_value_array_2(ctx, v1928);
                                                                                                let v1936 = C::unpack_value_array_2(ctx, v1934);
                                                                                                if v1930.0 == v1936.0 {
                                                                                                    if v1930.1 == v1936.1 {
                                                                                                        let mut v1326 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                        C::inst_data_value_tupled_etor(ctx, v155.1, &mut v1326);
                                                                                                        let mut v1326 = v1326.into_context_iter();
                                                                                                        while let Some(v1327) = v1326.next(ctx) {
                                                                                                            let v1328 = C::iconst_sextend_etor(ctx, v1327);
                                                                                                            if let Some(v1329) = v1328 {
                                                                                                                match v1329.1 {
                                                                                                                    -1_i64 => {
                                                                                                                        let v1947 = constructor_sge(ctx, v226.0, v1930.0, v1930.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 182.
                                                                                                                        returns.extend(Some(v1947));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                    0_i64 => {
                                                                                                                        let v1940 = constructor_ne(ctx, v226.0, v1930.0, v1930.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 150.
                                                                                                                        returns.extend(Some(v1940));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                    1_i64 => {
                                                                                                                        let v1943 = constructor_sle(ctx, v226.0, v1930.0, v1930.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 190.
                                                                                                                        returns.extend(Some(v1943));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                    _ => {}
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        if v159.0 == I8 {
                                                                            let mut v225 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v205.0, &mut v225);
                                                                            let mut v225 = v225.into_context_iter();
                                                                            while let Some(v226) = v225.next(ctx) {
                                                                                if let &InstructionData::IntCompare {
                                                                                    opcode: ref v1927,
                                                                                    args: ref v1928,
                                                                                    cond: ref v1929,
                                                                                } = &v226.1 {
                                                                                    if let &Opcode::Icmp = v1927 {
                                                                                        if let &IntCC::UnsignedGreaterThan = v1929 {
                                                                                            if v209.0 == v226.0 {
                                                                                                let v1930 = C::unpack_value_array_2(ctx, v1928);
                                                                                                let v1936 = C::unpack_value_array_2(ctx, v1934);
                                                                                                if v1930.0 == v1936.0 {
                                                                                                    if v1930.1 == v1936.1 {
                                                                                                        let mut v1326 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                        C::inst_data_value_tupled_etor(ctx, v155.1, &mut v1326);
                                                                                                        let mut v1326 = v1326.into_context_iter();
                                                                                                        while let Some(v1327) = v1326.next(ctx) {
                                                                                                            let v1328 = C::iconst_sextend_etor(ctx, v1327);
                                                                                                            if let Some(v1329) = v1328 {
                                                                                                                match v1329.1 {
                                                                                                                    -1_i64 => {
                                                                                                                        let v1948 = constructor_uge(ctx, v226.0, v1930.0, v1930.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 184.
                                                                                                                        returns.extend(Some(v1948));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                    0_i64 => {
                                                                                                                        let v1940 = constructor_ne(ctx, v226.0, v1930.0, v1930.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 152.
                                                                                                                        returns.extend(Some(v1940));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                    1_i64 => {
                                                                                                                        let v1944 = constructor_ule(ctx, v226.0, v1930.0, v1930.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 192.
                                                                                                                        returns.extend(Some(v1944));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                    _ => {}
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::UnaryImm {
                                                            opcode: ref v212,
                                                            imm: v213,
                                                        } => {
                                                            if let &Opcode::Iconst = v212 {
                                                                let mut v165 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v155.1, &mut v165);
                                                                let mut v165 = v165.into_context_iter();
                                                                while let Some(v166) = v165.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v215,
                                                                        imm: v216,
                                                                    } = &v166.1 {
                                                                        if let &Opcode::Iconst = v215 {
                                                                            let v1048 = constructor_iadd(ctx, v159.0, v155.1, v205.1);
                                                                            let v1050 = constructor_ne(ctx, v2.0, v205.0, v1048);
                                                                            // Rule at src/opts/cprop.isle line 253.
                                                                            returns.extend(Some(v1050));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let mut v165 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v155.1, &mut v165);
                                                let mut v165 = v165.into_context_iter();
                                                while let Some(v166) = v165.next(ctx) {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v169,
                                                        args: ref v170,
                                                    } = &v166.1 {
                                                        if let &Opcode::Isub = v169 {
                                                            let v171 = C::unpack_value_array_2(ctx, v170);
                                                            let v1379 = constructor_iadd(ctx, v159.0, v205.0, v171.1);
                                                            let v1380 = constructor_iadd(ctx, v166.0, v171.0, v205.1);
                                                            let v1382 = constructor_ne(ctx, v2.0, v1379, v1380);
                                                            // Rule at src/opts/icmp.isle line 42.
                                                            returns.extend(Some(v1382));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                            }
                                            &Opcode::Imul => {
                                                let mut v165 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v155.1, &mut v165);
                                                let mut v165 = v165.into_context_iter();
                                                while let Some(v166) = v165.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v215,
                                                        imm: v216,
                                                    } = &v166.1 {
                                                        if let &Opcode::Iconst = v215 {
                                                            if v159.0 == v166.0 {
                                                                let v205 = C::unpack_value_array_2(ctx, v204);
                                                                let mut v208 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v205.1, &mut v208);
                                                                let mut v208 = v208.into_context_iter();
                                                                while let Some(v209) = v208.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v212,
                                                                        imm: v213,
                                                                    } = &v209.1 {
                                                                        if let &Opcode::Iconst = v212 {
                                                                            let v217 = C::u64_from_imm64(ctx, v216);
                                                                            let v214 = C::u64_from_imm64(ctx, v213);
                                                                            let v218 = C::u64_checked_rem(ctx, v217, v214);
                                                                            if let Some(v219) = v218 {
                                                                                if v219 == 0x0_u64 {
                                                                                    let v220 = C::u64_rem(ctx, v214, 0x2_u64);
                                                                                    if v220 == 0x1_u64 {
                                                                                        if v159.0 == v209.0 {
                                                                                            let v221 = C::u64_div(ctx, v217, v214);
                                                                                            let v222 = C::imm64(ctx, v221);
                                                                                            let v223 = constructor_iconst(ctx, v159.0, v222);
                                                                                            let v224 = constructor_ne(ctx, v2.0, v205.0, v223);
                                                                                            // Rule at src/opts/arithmetic.isle line 262.
                                                                                            returns.extend(Some(v224));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                let mut v225 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v205.0, &mut v225);
                                                                let mut v225 = v225.into_context_iter();
                                                                while let Some(v226) = v225.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v229,
                                                                        imm: v230,
                                                                    } = &v226.1 {
                                                                        if let &Opcode::Iconst = v229 {
                                                                            let v217 = C::u64_from_imm64(ctx, v216);
                                                                            let v231 = C::u64_from_imm64(ctx, v230);
                                                                            let v232 = C::u64_checked_rem(ctx, v217, v231);
                                                                            if let Some(v233) = v232 {
                                                                                if v233 == 0x0_u64 {
                                                                                    let v234 = C::u64_rem(ctx, v231, 0x2_u64);
                                                                                    if v234 == 0x1_u64 {
                                                                                        if v159.0 == v226.0 {
                                                                                            let v235 = C::u64_div(ctx, v217, v231);
                                                                                            let v236 = C::imm64(ctx, v235);
                                                                                            let v237 = constructor_iconst(ctx, v159.0, v236);
                                                                                            let v238 = constructor_ne(ctx, v2.0, v205.1, v237);
                                                                                            // Rule at src/opts/arithmetic.isle line 267.
                                                                                            returns.extend(Some(v238));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            &Opcode::Bxor => {
                                                let mut v165 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v155.1, &mut v165);
                                                let mut v165 = v165.into_context_iter();
                                                while let Some(v166) = v165.next(ctx) {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v169,
                                                        args: ref v170,
                                                    } = &v166.1 {
                                                        if let &Opcode::Bxor = v169 {
                                                            if v159.0 == v166.0 {
                                                                let v171 = C::unpack_value_array_2(ctx, v170);
                                                                let v205 = C::unpack_value_array_2(ctx, v204);
                                                                if v171.0 == v205.0 {
                                                                    let v809 = constructor_ne(ctx, v2.0, v205.1, v171.1);
                                                                    // Rule at src/opts/bitops.isle line 460.
                                                                    returns.extend(Some(v809));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    let v810 = constructor_ne(ctx, v2.0, v171.1, v205.1);
                                                                    // Rule at src/opts/bitops.isle line 461.
                                                                    returns.extend(Some(v810));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v171.0 == v205.1 {
                                                                    let v805 = constructor_ne(ctx, v2.0, v205.0, v171.1);
                                                                    // Rule at src/opts/bitops.isle line 456.
                                                                    returns.extend(Some(v805));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    let v808 = constructor_ne(ctx, v2.0, v171.1, v205.0);
                                                                    // Rule at src/opts/bitops.isle line 459.
                                                                    returns.extend(Some(v808));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v171.1 == v205.0 {
                                                                    let v806 = constructor_ne(ctx, v2.0, v171.0, v205.1);
                                                                    // Rule at src/opts/bitops.isle line 457.
                                                                    returns.extend(Some(v806));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    let v807 = constructor_ne(ctx, v2.0, v205.1, v171.0);
                                                                    // Rule at src/opts/bitops.isle line 458.
                                                                    returns.extend(Some(v807));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v171.1 == v205.1 {
                                                                    let v803 = constructor_ne(ctx, v2.0, v205.0, v171.0);
                                                                    // Rule at src/opts/bitops.isle line 454.
                                                                    returns.extend(Some(v803));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    let v804 = constructor_ne(ctx, v2.0, v171.0, v205.0);
                                                                    // Rule at src/opts/bitops.isle line 455.
                                                                    returns.extend(Some(v804));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                    &InstructionData::Ternary {
                                        opcode: ref v1499,
                                        args: ref v1500,
                                    } => {
                                        if let &Opcode::Select = v1499 {
                                            let v1501 = C::unpack_value_array_3(ctx, v1500);
                                            if v155.1 == v1501.1 {
                                                let mut v1505 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v1501.0, &mut v1505);
                                                let mut v1505 = v1505.into_context_iter();
                                                while let Some(v1506) = v1505.next(ctx) {
                                                    if let &InstructionData::IntCompare {
                                                        opcode: ref v1509,
                                                        args: ref v1510,
                                                        cond: ref v1511,
                                                    } = &v1506.1 {
                                                        if let &Opcode::Icmp = v1509 {
                                                            match v1511 {
                                                                &IntCC::SignedLessThan => {
                                                                    if v2.0 == v1506.0 {
                                                                        let v1512 = C::unpack_value_array_2(ctx, v1510);
                                                                        if v155.1 == v1512.0 {
                                                                            if v1501.2 == v1512.1 {
                                                                                let v1515 = constructor_sgt(ctx, v2.0, v1512.0, v1512.1);
                                                                                // Rule at src/opts/icmp.isle line 302.
                                                                                returns.extend(Some(v1515));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &IntCC::UnsignedLessThan => {
                                                                    if v2.0 == v1506.0 {
                                                                        let v1512 = C::unpack_value_array_2(ctx, v1510);
                                                                        if v155.1 == v1512.0 {
                                                                            if v1501.2 == v1512.1 {
                                                                                let v1516 = constructor_ugt(ctx, v2.0, v1512.0, v1512.1);
                                                                                // Rule at src/opts/icmp.isle line 303.
                                                                                returns.extend(Some(v1516));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            let mut v165 = C::inst_data_value_etor_returns::default();
                                            C::inst_data_value_etor(ctx, v155.1, &mut v165);
                                            let mut v165 = v165.into_context_iter();
                                            while let Some(v166) = v165.next(ctx) {
                                                if let &InstructionData::UnaryImm {
                                                    opcode: ref v215,
                                                    imm: v216,
                                                } = &v166.1 {
                                                    if let &Opcode::Iconst = v215 {
                                                        let mut v1554 = C::inst_data_value_etor_returns::default();
                                                        C::inst_data_value_etor(ctx, v1501.1, &mut v1554);
                                                        let mut v1554 = v1554.into_context_iter();
                                                        while let Some(v1555) = v1554.next(ctx) {
                                                            if let &InstructionData::UnaryImm {
                                                                opcode: ref v1558,
                                                                imm: v1559,
                                                            } = &v1555.1 {
                                                                if let &Opcode::Iconst = v1558 {
                                                                    let mut v1561 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v1501.2, &mut v1561);
                                                                    let mut v1561 = v1561.into_context_iter();
                                                                    while let Some(v1562) = v1561.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v1565,
                                                                            imm: v1566,
                                                                        } = &v1562.1 {
                                                                            if let &Opcode::Iconst = v1565 {
                                                                                let v1560 = C::u64_from_imm64(ctx, v1559);
                                                                                let v1567 = C::u64_from_imm64(ctx, v1566);
                                                                                let v1568 = C::u64_eq(ctx, v1560, v1567);
                                                                                if v1568 == false {
                                                                                    let v217 = C::u64_from_imm64(ctx, v216);
                                                                                    if v217 == v1560 {
                                                                                        let v1553 = C::value_type(ctx, v1501.0);
                                                                                        let v1569 = constructor_iconst_u(ctx, v1553, 0x0_u64);
                                                                                        let v1571 = constructor_eq(ctx, v159.0, v1501.0, v1569);
                                                                                        // Rule at src/opts/icmp.isle line 401.
                                                                                        returns.extend(Some(v1571));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v217 == v1567 {
                                                                                        let v1553 = C::value_type(ctx, v1501.0);
                                                                                        let v1569 = constructor_iconst_u(ctx, v1553, 0x0_u64);
                                                                                        let v1570 = constructor_ne(ctx, v159.0, v1501.0, v1569);
                                                                                        // Rule at src/opts/icmp.isle line 409.
                                                                                        returns.extend(Some(v1570));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    &InstructionData::Unary {
                                        opcode: ref v256,
                                        arg: v257,
                                    } => {
                                        if let &Opcode::Sextend = v256 {
                                            let mut v1326 = C::inst_data_value_tupled_etor_returns::default();
                                            C::inst_data_value_tupled_etor(ctx, v155.1, &mut v1326);
                                            let mut v1326 = v1326.into_context_iter();
                                            while let Some(v1327) = v1326.next(ctx) {
                                                let v1328 = C::iconst_sextend_etor(ctx, v1327);
                                                if let Some(v1329) = v1328 {
                                                    if v1329.1 == 0_i64 {
                                                        let v1322 = C::value_type(ctx, v257);
                                                        let v1333 = constructor_iconst_s(ctx, v1322, 0_i64);
                                                        let v1335 = constructor_ne(ctx, v1322, v257, v1333);
                                                        // Rule at src/opts/extends.isle line 41.
                                                        returns.extend(Some(v1335));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    &InstructionData::UnaryImm {
                                        opcode: ref v162,
                                        imm: v163,
                                    } => {
                                        if let &Opcode::Iconst = v162 {
                                            let mut v165 = C::inst_data_value_etor_returns::default();
                                            C::inst_data_value_etor(ctx, v155.1, &mut v165);
                                            let mut v165 = v165.into_context_iter();
                                            while let Some(v166) = v165.next(ctx) {
                                                if let &InstructionData::Binary {
                                                    opcode: ref v169,
                                                    args: ref v170,
                                                } = &v166.1 {
                                                    if let &Opcode::Imul = v169 {
                                                        if v159.0 == v166.0 {
                                                            let v171 = C::unpack_value_array_2(ctx, v170);
                                                            let mut v174 = C::inst_data_value_etor_returns::default();
                                                            C::inst_data_value_etor(ctx, v171.1, &mut v174);
                                                            let mut v174 = v174.into_context_iter();
                                                            while let Some(v175) = v174.next(ctx) {
                                                                if let &InstructionData::UnaryImm {
                                                                    opcode: ref v178,
                                                                    imm: v179,
                                                                } = &v175.1 {
                                                                    if let &Opcode::Iconst = v178 {
                                                                        let v164 = C::u64_from_imm64(ctx, v163);
                                                                        let v180 = C::u64_from_imm64(ctx, v179);
                                                                        let v181 = C::u64_checked_rem(ctx, v164, v180);
                                                                        if let Some(v182) = v181 {
                                                                            if v182 == 0x0_u64 {
                                                                                let v184 = C::u64_rem(ctx, v180, 0x2_u64);
                                                                                if v184 == 0x1_u64 {
                                                                                    if v159.0 == v175.0 {
                                                                                        let v185 = C::u64_div(ctx, v164, v180);
                                                                                        let v186 = C::imm64(ctx, v185);
                                                                                        let v187 = constructor_iconst(ctx, v159.0, v186);
                                                                                        let v188 = constructor_ne(ctx, v2.0, v171.0, v187);
                                                                                        // Rule at src/opts/arithmetic.isle line 252.
                                                                                        returns.extend(Some(v188));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            let mut v189 = C::inst_data_value_etor_returns::default();
                                                            C::inst_data_value_etor(ctx, v171.0, &mut v189);
                                                            let mut v189 = v189.into_context_iter();
                                                            while let Some(v190) = v189.next(ctx) {
                                                                if let &InstructionData::UnaryImm {
                                                                    opcode: ref v193,
                                                                    imm: v194,
                                                                } = &v190.1 {
                                                                    if let &Opcode::Iconst = v193 {
                                                                        let v164 = C::u64_from_imm64(ctx, v163);
                                                                        let v195 = C::u64_from_imm64(ctx, v194);
                                                                        let v196 = C::u64_checked_rem(ctx, v164, v195);
                                                                        if let Some(v197) = v196 {
                                                                            if v197 == 0x0_u64 {
                                                                                let v198 = C::u64_rem(ctx, v195, 0x2_u64);
                                                                                if v198 == 0x1_u64 {
                                                                                    if v159.0 == v190.0 {
                                                                                        let v199 = C::u64_div(ctx, v164, v195);
                                                                                        let v200 = C::imm64(ctx, v199);
                                                                                        let v201 = constructor_iconst(ctx, v159.0, v200);
                                                                                        let v202 = constructor_ne(ctx, v2.0, v171.1, v201);
                                                                                        // Rule at src/opts/arithmetic.isle line 257.
                                                                                        returns.extend(Some(v202));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                            let mut v165 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v155.1, &mut v165);
                            let mut v165 = v165.into_context_iter();
                            while let Some(v166) = v165.next(ctx) {
                                match &v166.1 {
                                    &InstructionData::Binary {
                                        opcode: ref v169,
                                        args: ref v170,
                                    } => {
                                        if let &Opcode::Bxor = v169 {
                                            let v1490 = C::ty_int(ctx, v166.0);
                                            if let Some(v1491) = v1490 {
                                                let v171 = C::unpack_value_array_2(ctx, v170);
                                                if v155.0 == v171.0 {
                                                    let v1492 = constructor_iconst_u(ctx, v1491, 0x0_u64);
                                                    let v1495 = constructor_ne(ctx, v2.0, v171.1, v1492);
                                                    let v1496 = C::subsume(ctx, v1495);
                                                    // Rule at src/opts/icmp.isle line 295.
                                                    returns.extend(Some(v1496));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                    &InstructionData::UnaryImm {
                                        opcode: ref v215,
                                        imm: v216,
                                    } => {
                                        if let &Opcode::Iconst = v215 {
                                            let v217 = C::u64_from_imm64(ctx, v216);
                                            match v217 {
                                                0x0_u64 => {
                                                    let mut v1383 = C::uextend_maybe_etor_returns::default();
                                                    C::uextend_maybe_etor(ctx, v155.0, &mut v1383);
                                                    let mut v1383 = v1383.into_context_iter();
                                                    while let Some(v1384) = v1383.next(ctx) {
                                                        let mut v1387 = C::inst_data_value_etor_returns::default();
                                                        C::inst_data_value_etor(ctx, v1384.1, &mut v1387);
                                                        let mut v1387 = v1387.into_context_iter();
                                                        while let Some(v1388) = v1387.next(ctx) {
                                                            match &v1388.1 {
                                                                &InstructionData::FloatCompare {
                                                                    opcode: ref v1398,
                                                                    args: ref v1399,
                                                                    cond: ref v1400,
                                                                } => {
                                                                    if let &Opcode::Fcmp = v1398 {
                                                                        if v2.0 == v1388.0 {
                                                                            let v1397 = C::subsume(ctx, v1384.1);
                                                                            // Rule at src/opts/icmp.isle line 55.
                                                                            returns.extend(Some(v1397));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                &InstructionData::IntCompare {
                                                                    opcode: ref v1391,
                                                                    args: ref v1392,
                                                                    cond: ref v1393,
                                                                } => {
                                                                    if let &Opcode::Icmp = v1391 {
                                                                        if v2.0 == v1388.0 {
                                                                            let v1397 = C::subsume(ctx, v1384.1);
                                                                            // Rule at src/opts/icmp.isle line 48.
                                                                            returns.extend(Some(v1397));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                    }
                                                    let mut v334 = ContextIterWrapper::<ConstructorVec<_>, _>::default();
                                                    constructor_truthy(ctx, v155.0, &mut v334);
                                                    let mut v334 = v334.into_context_iter();
                                                    while let Some(v335) = v334.next(ctx) {
                                                        let v336 = C::value_type(ctx, v335);
                                                        let v337 = C::ty_int_ref_scalar_64_extract(ctx, v336);
                                                        if let Some(v338) = v337 {
                                                            let v339 = constructor_iconst_u(ctx, v338, 0x0_u64);
                                                            let v340 = constructor_ne(ctx, v2.0, v335, v339);
                                                            // Rule at src/opts/bitops.isle line 114.
                                                            returns.extend(Some(v340));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                                0x1_u64 => {
                                                    let mut v1383 = C::uextend_maybe_etor_returns::default();
                                                    C::uextend_maybe_etor(ctx, v155.0, &mut v1383);
                                                    let mut v1383 = v1383.into_context_iter();
                                                    while let Some(v1384) = v1383.next(ctx) {
                                                        let mut v1387 = C::inst_data_value_etor_returns::default();
                                                        C::inst_data_value_etor(ctx, v1384.1, &mut v1387);
                                                        let mut v1387 = v1387.into_context_iter();
                                                        while let Some(v1388) = v1387.next(ctx) {
                                                            if let &InstructionData::IntCompare {
                                                                opcode: ref v1391,
                                                                args: ref v1392,
                                                                cond: ref v1393,
                                                            } = &v1388.1 {
                                                                if let &Opcode::Icmp = v1391 {
                                                                    if v2.0 == v1388.0 {
                                                                        let v1404 = &C::intcc_complement(ctx, v1393);
                                                                        let v1394 = C::unpack_value_array_2(ctx, v1392);
                                                                        let v1405 = constructor_icmp(ctx, v2.0, v1404, v1394.0, v1394.1);
                                                                        let v1406 = C::subsume(ctx, v1405);
                                                                        // Rule at src/opts/icmp.isle line 69.
                                                                        returns.extend(Some(v1406));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                _ => {}
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                            if v155.0 == v155.1 {
                                let v297 = C::ty_int(ctx, v2.0);
                                if let Some(v298) = v297 {
                                    let v299 = constructor_iconst_u(ctx, v298, 0x0_u64);
                                    let v300 = C::subsume(ctx, v299);
                                    // Rule at src/opts/icmp.isle line 5.
                                    returns.extend(Some(v300));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                        }
                        &IntCC::SignedGreaterThan => {
                            let v292 = C::fits_in_64(ctx, v2.0);
                            if let Some(v293) = v292 {
                                let v1424 = C::ty_int(ctx, v293);
                                if let Some(v1425) = v1424 {
                                    let v155 = C::unpack_value_array_2(ctx, v153);
                                    let mut v165 = C::inst_data_value_etor_returns::default();
                                    C::inst_data_value_etor(ctx, v155.1, &mut v165);
                                    let mut v165 = v165.into_context_iter();
                                    while let Some(v166) = v165.next(ctx) {
                                        if let &InstructionData::UnaryImm {
                                            opcode: ref v215,
                                            imm: v216,
                                        } = &v166.1 {
                                            if let &Opcode::Iconst = v215 {
                                                let v217 = C::u64_from_imm64(ctx, v216);
                                                let v1435 = C::ty_smin(ctx, v166.0);
                                                let v1436 = C::u64_eq(ctx, v217, v1435);
                                                if v1436 == true {
                                                    let v1427 = constructor_ne(ctx, v1425, v155.0, v155.1);
                                                    // Rule at src/opts/icmp.isle line 149.
                                                    returns.extend(Some(v1427));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let v1437 = C::ty_smax(ctx, v166.0);
                                                let v1438 = C::u64_eq(ctx, v217, v1437);
                                                if v1438 == true {
                                                    let v1433 = constructor_iconst_u(ctx, v1425, 0x0_u64);
                                                    let v1434 = C::subsume(ctx, v1433);
                                                    // Rule at src/opts/icmp.isle line 169.
                                                    returns.extend(Some(v1434));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                                let v155 = C::unpack_value_array_2(ctx, v153);
                                let mut v158 = C::inst_data_value_etor_returns::default();
                                C::inst_data_value_etor(ctx, v155.0, &mut v158);
                                let mut v158 = v158.into_context_iter();
                                while let Some(v159) = v158.next(ctx) {
                                    if let &InstructionData::Binary {
                                        opcode: ref v203,
                                        args: ref v204,
                                    } = &v159.1 {
                                        if let &Opcode::Smin = v203 {
                                            let v205 = C::unpack_value_array_2(ctx, v204);
                                            if v155.1 == v205.0 {
                                                let v1673 = constructor_iconst_u(ctx, v293, 0x0_u64);
                                                // Rule at src/opts/selects.isle line 105.
                                                returns.extend(Some(v1673));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            if v155.1 == v205.1 {
                                                let v1673 = constructor_iconst_u(ctx, v293, 0x0_u64);
                                                // Rule at src/opts/selects.isle line 106.
                                                returns.extend(Some(v1673));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                }
                            }
                            let v155 = C::unpack_value_array_2(ctx, v153);
                            let mut v1326 = C::inst_data_value_tupled_etor_returns::default();
                            C::inst_data_value_tupled_etor(ctx, v155.1, &mut v1326);
                            let mut v1326 = v1326.into_context_iter();
                            while let Some(v1327) = v1326.next(ctx) {
                                let v1328 = C::iconst_sextend_etor(ctx, v1327);
                                if let Some(v1329) = v1328 {
                                    match v1329.1 {
                                        -1_i64 => {
                                            let v1449 = constructor_iconst_s(ctx, v1329.0, 0_i64);
                                            let v1452 = constructor_sge(ctx, v2.0, v155.0, v1449);
                                            // Rule at src/opts/icmp.isle line 201.
                                            returns.extend(Some(v1452));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        0_i64 => {
                                            let mut v158 = C::inst_data_value_etor_returns::default();
                                            C::inst_data_value_etor(ctx, v155.0, &mut v158);
                                            let mut v158 = v158.into_context_iter();
                                            while let Some(v159) = v158.next(ctx) {
                                                if v159.0 == I8 {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v203,
                                                        args: ref v204,
                                                    } = &v159.1 {
                                                        if let &Opcode::Isub = v203 {
                                                            let v205 = C::unpack_value_array_2(ctx, v204);
                                                            let mut v208 = C::inst_data_value_etor_returns::default();
                                                            C::inst_data_value_etor(ctx, v205.1, &mut v208);
                                                            let mut v208 = v208.into_context_iter();
                                                            while let Some(v209) = v208.next(ctx) {
                                                                if let &InstructionData::IntCompare {
                                                                    opcode: ref v1933,
                                                                    args: ref v1934,
                                                                    cond: ref v1935,
                                                                } = &v209.1 {
                                                                    if let &Opcode::Icmp = v1933 {
                                                                        match v1935 {
                                                                            &IntCC::SignedLessThan => {
                                                                                let mut v225 = C::inst_data_value_etor_returns::default();
                                                                                C::inst_data_value_etor(ctx, v205.0, &mut v225);
                                                                                let mut v225 = v225.into_context_iter();
                                                                                while let Some(v226) = v225.next(ctx) {
                                                                                    if let &InstructionData::IntCompare {
                                                                                        opcode: ref v1927,
                                                                                        args: ref v1928,
                                                                                        cond: ref v1929,
                                                                                    } = &v226.1 {
                                                                                        if let &Opcode::Icmp = v1927 {
                                                                                            if let &IntCC::SignedGreaterThan = v1929 {
                                                                                                if v209.0 == v226.0 {
                                                                                                    let v1930 = C::unpack_value_array_2(ctx, v1928);
                                                                                                    let v1936 = C::unpack_value_array_2(ctx, v1934);
                                                                                                    if v1930.0 == v1936.0 {
                                                                                                        if v1930.1 == v1936.1 {
                                                                                                            let v1945 = constructor_sgt(ctx, v226.0, v1930.0, v1930.1);
                                                                                                            // Rule at src/opts/spaceship.isle line 166.
                                                                                                            returns.extend(Some(v1945));
                                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            &IntCC::UnsignedLessThan => {
                                                                                let mut v225 = C::inst_data_value_etor_returns::default();
                                                                                C::inst_data_value_etor(ctx, v205.0, &mut v225);
                                                                                let mut v225 = v225.into_context_iter();
                                                                                while let Some(v226) = v225.next(ctx) {
                                                                                    if let &InstructionData::IntCompare {
                                                                                        opcode: ref v1927,
                                                                                        args: ref v1928,
                                                                                        cond: ref v1929,
                                                                                    } = &v226.1 {
                                                                                        if let &Opcode::Icmp = v1927 {
                                                                                            if let &IntCC::UnsignedGreaterThan = v1929 {
                                                                                                if v209.0 == v226.0 {
                                                                                                    let v1930 = C::unpack_value_array_2(ctx, v1928);
                                                                                                    let v1936 = C::unpack_value_array_2(ctx, v1934);
                                                                                                    if v1930.0 == v1936.0 {
                                                                                                        if v1930.1 == v1936.1 {
                                                                                                            let v1946 = constructor_ugt(ctx, v226.0, v1930.0, v1930.1);
                                                                                                            // Rule at src/opts/spaceship.isle line 168.
                                                                                                            returns.extend(Some(v1946));
                                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            _ => {}
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                            }
                            let mut v165 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v155.1, &mut v165);
                            let mut v165 = v165.into_context_iter();
                            while let Some(v166) = v165.next(ctx) {
                                if let &InstructionData::Binary {
                                    opcode: ref v169,
                                    args: ref v170,
                                } = &v166.1 {
                                    if let &Opcode::Smax = v169 {
                                        if v2.0 == v166.0 {
                                            let v171 = C::unpack_value_array_2(ctx, v170);
                                            if v155.0 == v171.0 {
                                                let v53 = constructor_iconst_u(ctx, v2.0, 0x0_u64);
                                                // Rule at src/opts/arithmetic.isle line 497.
                                                returns.extend(Some(v53));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            if v155.0 == v171.1 {
                                                let v53 = constructor_iconst_u(ctx, v2.0, 0x0_u64);
                                                // Rule at src/opts/arithmetic.isle line 498.
                                                returns.extend(Some(v53));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                }
                            }
                            let v297 = C::ty_int(ctx, v2.0);
                            if let Some(v298) = v297 {
                                if v155.0 == v155.1 {
                                    let v299 = constructor_iconst_u(ctx, v298, 0x0_u64);
                                    let v300 = C::subsume(ctx, v299);
                                    // Rule at src/opts/icmp.isle line 8.
                                    returns.extend(Some(v300));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                        }
                        &IntCC::SignedGreaterThanOrEqual => {
                            let v155 = C::unpack_value_array_2(ctx, v153);
                            let mut v158 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v155.0, &mut v158);
                            let mut v158 = v158.into_context_iter();
                            while let Some(v159) = v158.next(ctx) {
                                match &v159.1 {
                                    &InstructionData::Binary {
                                        opcode: ref v203,
                                        args: ref v204,
                                    } => {
                                        match v203 {
                                            &Opcode::Smax => {
                                                if v2.0 == v159.0 {
                                                    let v205 = C::unpack_value_array_2(ctx, v204);
                                                    if v155.1 == v205.0 {
                                                        let v275 = constructor_cmp_true(ctx, v2.0);
                                                        // Rule at src/opts/arithmetic.isle line 351.
                                                        returns.extend(Some(v275));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                    if v155.1 == v205.1 {
                                                        let v275 = constructor_cmp_true(ctx, v2.0);
                                                        // Rule at src/opts/arithmetic.isle line 352.
                                                        returns.extend(Some(v275));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &Opcode::Isub => {
                                                if v159.0 == I8 {
                                                    let v205 = C::unpack_value_array_2(ctx, v204);
                                                    let mut v208 = C::inst_data_value_etor_returns::default();
                                                    C::inst_data_value_etor(ctx, v205.1, &mut v208);
                                                    let mut v208 = v208.into_context_iter();
                                                    while let Some(v209) = v208.next(ctx) {
                                                        if let &InstructionData::IntCompare {
                                                            opcode: ref v1933,
                                                            args: ref v1934,
                                                            cond: ref v1935,
                                                        } = &v209.1 {
                                                            if let &Opcode::Icmp = v1933 {
                                                                match v1935 {
                                                                    &IntCC::SignedLessThan => {
                                                                        let mut v225 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v205.0, &mut v225);
                                                                        let mut v225 = v225.into_context_iter();
                                                                        while let Some(v226) = v225.next(ctx) {
                                                                            if let &InstructionData::IntCompare {
                                                                                opcode: ref v1927,
                                                                                args: ref v1928,
                                                                                cond: ref v1929,
                                                                            } = &v226.1 {
                                                                                if let &Opcode::Icmp = v1927 {
                                                                                    if let &IntCC::SignedGreaterThan = v1929 {
                                                                                        if v209.0 == v226.0 {
                                                                                            let v1930 = C::unpack_value_array_2(ctx, v1928);
                                                                                            let v1936 = C::unpack_value_array_2(ctx, v1934);
                                                                                            if v1930.0 == v1936.0 {
                                                                                                if v1930.1 == v1936.1 {
                                                                                                    let mut v1326 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                    C::inst_data_value_tupled_etor(ctx, v155.1, &mut v1326);
                                                                                                    let mut v1326 = v1326.into_context_iter();
                                                                                                    while let Some(v1327) = v1326.next(ctx) {
                                                                                                        let v1328 = C::iconst_sextend_etor(ctx, v1327);
                                                                                                        if let Some(v1329) = v1328 {
                                                                                                            if v1329.1 == 0_i64 {
                                                                                                                let v1947 = constructor_sge(ctx, v226.0, v1930.0, v1930.1);
                                                                                                                // Rule at src/opts/spaceship.isle line 171.
                                                                                                                returns.extend(Some(v1947));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        let mut v225 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v205.0, &mut v225);
                                                                        let mut v225 = v225.into_context_iter();
                                                                        while let Some(v226) = v225.next(ctx) {
                                                                            if let &InstructionData::IntCompare {
                                                                                opcode: ref v1927,
                                                                                args: ref v1928,
                                                                                cond: ref v1929,
                                                                            } = &v226.1 {
                                                                                if let &Opcode::Icmp = v1927 {
                                                                                    if let &IntCC::UnsignedGreaterThan = v1929 {
                                                                                        if v209.0 == v226.0 {
                                                                                            let v1930 = C::unpack_value_array_2(ctx, v1928);
                                                                                            let v1936 = C::unpack_value_array_2(ctx, v1934);
                                                                                            if v1930.0 == v1936.0 {
                                                                                                if v1930.1 == v1936.1 {
                                                                                                    let mut v1326 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                    C::inst_data_value_tupled_etor(ctx, v155.1, &mut v1326);
                                                                                                    let mut v1326 = v1326.into_context_iter();
                                                                                                    while let Some(v1327) = v1326.next(ctx) {
                                                                                                        let v1328 = C::iconst_sextend_etor(ctx, v1327);
                                                                                                        if let Some(v1329) = v1328 {
                                                                                                            if v1329.1 == 0_i64 {
                                                                                                                let v1948 = constructor_uge(ctx, v226.0, v1930.0, v1930.1);
                                                                                                                // Rule at src/opts/spaceship.isle line 173.
                                                                                                                returns.extend(Some(v1948));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                    &InstructionData::Unary {
                                        opcode: ref v256,
                                        arg: v257,
                                    } => {
                                        if let &Opcode::Uextend = v256 {
                                            if v159.0 == I64 {
                                                let v1322 = C::value_type(ctx, v257);
                                                if v1322 == I32 {
                                                    let mut v165 = C::inst_data_value_etor_returns::default();
                                                    C::inst_data_value_etor(ctx, v155.1, &mut v165);
                                                    let mut v165 = v165.into_context_iter();
                                                    while let Some(v166) = v165.next(ctx) {
                                                        if let &InstructionData::UnaryImm {
                                                            opcode: ref v215,
                                                            imm: v216,
                                                        } = &v166.1 {
                                                            if let &Opcode::Iconst = v215 {
                                                                let v217 = C::u64_from_imm64(ctx, v216);
                                                                if v217 == 0x0_u64 {
                                                                    let v1324 = constructor_iconst_u(ctx, v2.0, 0x1_u64);
                                                                    let v1325 = C::subsume(ctx, v1324);
                                                                    // Rule at src/opts/extends.isle line 32.
                                                                    returns.extend(Some(v1325));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                            let mut v165 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v155.1, &mut v165);
                            let mut v165 = v165.into_context_iter();
                            while let Some(v166) = v165.next(ctx) {
                                match &v166.1 {
                                    &InstructionData::Binary {
                                        opcode: ref v169,
                                        args: ref v170,
                                    } => {
                                        if let &Opcode::Smin = v169 {
                                            if v2.0 == v166.0 {
                                                let v171 = C::unpack_value_array_2(ctx, v170);
                                                if v155.0 == v171.0 {
                                                    let v275 = constructor_cmp_true(ctx, v2.0);
                                                    // Rule at src/opts/arithmetic.isle line 361.
                                                    returns.extend(Some(v275));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v155.0 == v171.1 {
                                                    let v275 = constructor_cmp_true(ctx, v2.0);
                                                    // Rule at src/opts/arithmetic.isle line 362.
                                                    returns.extend(Some(v275));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                    &InstructionData::UnaryImm {
                                        opcode: ref v215,
                                        imm: v216,
                                    } => {
                                        if let &Opcode::Iconst = v215 {
                                            let v292 = C::fits_in_64(ctx, v2.0);
                                            if let Some(v293) = v292 {
                                                let v1424 = C::ty_int(ctx, v293);
                                                if let Some(v1425) = v1424 {
                                                    let v217 = C::u64_from_imm64(ctx, v216);
                                                    let v1435 = C::ty_smin(ctx, v166.0);
                                                    let v1436 = C::u64_eq(ctx, v217, v1435);
                                                    if v1436 == true {
                                                        let v1431 = constructor_iconst_u(ctx, v1425, 0x1_u64);
                                                        let v1432 = C::subsume(ctx, v1431);
                                                        // Rule at src/opts/icmp.isle line 154.
                                                        returns.extend(Some(v1432));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                    let v1437 = C::ty_smax(ctx, v166.0);
                                                    let v1438 = C::u64_eq(ctx, v217, v1437);
                                                    if v1438 == true {
                                                        let v1426 = constructor_eq(ctx, v1425, v155.0, v155.1);
                                                        // Rule at src/opts/icmp.isle line 174.
                                                        returns.extend(Some(v1426));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                            if v155.0 == v155.1 {
                                let v297 = C::ty_int(ctx, v2.0);
                                if let Some(v298) = v297 {
                                    let v1369 = constructor_iconst_u(ctx, v298, 0x1_u64);
                                    let v1370 = C::subsume(ctx, v1369);
                                    // Rule at src/opts/icmp.isle line 9.
                                    returns.extend(Some(v1370));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                            let mut v1326 = C::inst_data_value_tupled_etor_returns::default();
                            C::inst_data_value_tupled_etor(ctx, v155.1, &mut v1326);
                            let mut v1326 = v1326.into_context_iter();
                            while let Some(v1327) = v1326.next(ctx) {
                                let v1328 = C::iconst_sextend_etor(ctx, v1327);
                                if let Some(v1329) = v1328 {
                                    if v1329.1 == 1_i64 {
                                        let v1449 = constructor_iconst_s(ctx, v1329.0, 0_i64);
                                        let v1450 = constructor_sgt(ctx, v2.0, v155.0, v1449);
                                        // Rule at src/opts/icmp.isle line 195.
                                        returns.extend(Some(v1450));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                            }
                        }
                        &IntCC::SignedLessThan => {
                            let v155 = C::unpack_value_array_2(ctx, v153);
                            let mut v158 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v155.0, &mut v158);
                            let mut v158 = v158.into_context_iter();
                            while let Some(v159) = v158.next(ctx) {
                                match &v159.1 {
                                    &InstructionData::Binary {
                                        opcode: ref v203,
                                        args: ref v204,
                                    } => {
                                        match v203 {
                                            &Opcode::Smax => {
                                                if v2.0 == v159.0 {
                                                    let v205 = C::unpack_value_array_2(ctx, v204);
                                                    if v155.1 == v205.0 {
                                                        let v53 = constructor_iconst_u(ctx, v2.0, 0x0_u64);
                                                        // Rule at src/opts/arithmetic.isle line 499.
                                                        returns.extend(Some(v53));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                    if v155.1 == v205.1 {
                                                        let v53 = constructor_iconst_u(ctx, v2.0, 0x0_u64);
                                                        // Rule at src/opts/arithmetic.isle line 500.
                                                        returns.extend(Some(v53));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &Opcode::Isub => {
                                                if v159.0 == I8 {
                                                    let v205 = C::unpack_value_array_2(ctx, v204);
                                                    let mut v208 = C::inst_data_value_etor_returns::default();
                                                    C::inst_data_value_etor(ctx, v205.1, &mut v208);
                                                    let mut v208 = v208.into_context_iter();
                                                    while let Some(v209) = v208.next(ctx) {
                                                        if let &InstructionData::IntCompare {
                                                            opcode: ref v1933,
                                                            args: ref v1934,
                                                            cond: ref v1935,
                                                        } = &v209.1 {
                                                            if let &Opcode::Icmp = v1933 {
                                                                match v1935 {
                                                                    &IntCC::SignedLessThan => {
                                                                        let mut v225 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v205.0, &mut v225);
                                                                        let mut v225 = v225.into_context_iter();
                                                                        while let Some(v226) = v225.next(ctx) {
                                                                            if let &InstructionData::IntCompare {
                                                                                opcode: ref v1927,
                                                                                args: ref v1928,
                                                                                cond: ref v1929,
                                                                            } = &v226.1 {
                                                                                if let &Opcode::Icmp = v1927 {
                                                                                    if let &IntCC::SignedGreaterThan = v1929 {
                                                                                        if v209.0 == v226.0 {
                                                                                            let v1930 = C::unpack_value_array_2(ctx, v1928);
                                                                                            let v1936 = C::unpack_value_array_2(ctx, v1934);
                                                                                            if v1930.0 == v1936.0 {
                                                                                                if v1930.1 == v1936.1 {
                                                                                                    let mut v1326 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                    C::inst_data_value_tupled_etor(ctx, v155.1, &mut v1326);
                                                                                                    let mut v1326 = v1326.into_context_iter();
                                                                                                    while let Some(v1327) = v1326.next(ctx) {
                                                                                                        let v1328 = C::iconst_sextend_etor(ctx, v1327);
                                                                                                        if let Some(v1329) = v1328 {
                                                                                                            if v1329.1 == 0_i64 {
                                                                                                                let v1941 = constructor_slt(ctx, v226.0, v1930.0, v1930.1);
                                                                                                                // Rule at src/opts/spaceship.isle line 156.
                                                                                                                returns.extend(Some(v1941));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        let mut v225 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v205.0, &mut v225);
                                                                        let mut v225 = v225.into_context_iter();
                                                                        while let Some(v226) = v225.next(ctx) {
                                                                            if let &InstructionData::IntCompare {
                                                                                opcode: ref v1927,
                                                                                args: ref v1928,
                                                                                cond: ref v1929,
                                                                            } = &v226.1 {
                                                                                if let &Opcode::Icmp = v1927 {
                                                                                    if let &IntCC::UnsignedGreaterThan = v1929 {
                                                                                        if v209.0 == v226.0 {
                                                                                            let v1930 = C::unpack_value_array_2(ctx, v1928);
                                                                                            let v1936 = C::unpack_value_array_2(ctx, v1934);
                                                                                            if v1930.0 == v1936.0 {
                                                                                                if v1930.1 == v1936.1 {
                                                                                                    let mut v1326 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                    C::inst_data_value_tupled_etor(ctx, v155.1, &mut v1326);
                                                                                                    let mut v1326 = v1326.into_context_iter();
                                                                                                    while let Some(v1327) = v1326.next(ctx) {
                                                                                                        let v1328 = C::iconst_sextend_etor(ctx, v1327);
                                                                                                        if let Some(v1329) = v1328 {
                                                                                                            if v1329.1 == 0_i64 {
                                                                                                                let v1942 = constructor_ult(ctx, v226.0, v1930.0, v1930.1);
                                                                                                                // Rule at src/opts/spaceship.isle line 158.
                                                                                                                returns.extend(Some(v1942));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                    &InstructionData::Unary {
                                        opcode: ref v256,
                                        arg: v257,
                                    } => {
                                        match v256 {
                                            &Opcode::Bnot => {
                                                let mut v165 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v155.1, &mut v165);
                                                let mut v165 = v165.into_context_iter();
                                                while let Some(v166) = v165.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v258,
                                                        arg: v259,
                                                    } = &v166.1 {
                                                        if let &Opcode::Bnot = v258 {
                                                            if v159.0 == v166.0 {
                                                                let v1518 = constructor_sgt(ctx, v2.0, v257, v259);
                                                                // Rule at src/opts/icmp.isle line 306.
                                                                returns.extend(Some(v1518));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            &Opcode::Uextend => {
                                                if v159.0 == I64 {
                                                    let v1322 = C::value_type(ctx, v257);
                                                    if v1322 == I32 {
                                                        let mut v165 = C::inst_data_value_etor_returns::default();
                                                        C::inst_data_value_etor(ctx, v155.1, &mut v165);
                                                        let mut v165 = v165.into_context_iter();
                                                        while let Some(v166) = v165.next(ctx) {
                                                            if let &InstructionData::UnaryImm {
                                                                opcode: ref v215,
                                                                imm: v216,
                                                            } = &v166.1 {
                                                                if let &Opcode::Iconst = v215 {
                                                                    let v217 = C::u64_from_imm64(ctx, v216);
                                                                    if v217 == 0x0_u64 {
                                                                        let v53 = constructor_iconst_u(ctx, v2.0, 0x0_u64);
                                                                        let v54 = C::subsume(ctx, v53);
                                                                        // Rule at src/opts/extends.isle line 27.
                                                                        returns.extend(Some(v54));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                    _ => {}
                                }
                            }
                            let v292 = C::fits_in_64(ctx, v2.0);
                            if let Some(v293) = v292 {
                                let mut v165 = C::inst_data_value_etor_returns::default();
                                C::inst_data_value_etor(ctx, v155.1, &mut v165);
                                let mut v165 = v165.into_context_iter();
                                while let Some(v166) = v165.next(ctx) {
                                    match &v166.1 {
                                        &InstructionData::Binary {
                                            opcode: ref v169,
                                            args: ref v170,
                                        } => {
                                            if let &Opcode::Smin = v169 {
                                                let v171 = C::unpack_value_array_2(ctx, v170);
                                                if v155.0 == v171.0 {
                                                    let v1673 = constructor_iconst_u(ctx, v293, 0x0_u64);
                                                    // Rule at src/opts/selects.isle line 107.
                                                    returns.extend(Some(v1673));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v155.0 == v171.1 {
                                                    let v1673 = constructor_iconst_u(ctx, v293, 0x0_u64);
                                                    // Rule at src/opts/selects.isle line 108.
                                                    returns.extend(Some(v1673));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        &InstructionData::UnaryImm {
                                            opcode: ref v215,
                                            imm: v216,
                                        } => {
                                            if let &Opcode::Iconst = v215 {
                                                let v1424 = C::ty_int(ctx, v293);
                                                if let Some(v1425) = v1424 {
                                                    let v217 = C::u64_from_imm64(ctx, v216);
                                                    let v1435 = C::ty_smin(ctx, v166.0);
                                                    let v1436 = C::u64_eq(ctx, v217, v1435);
                                                    if v1436 == true {
                                                        let v1433 = constructor_iconst_u(ctx, v1425, 0x0_u64);
                                                        let v1434 = C::subsume(ctx, v1433);
                                                        // Rule at src/opts/icmp.isle line 139.
                                                        returns.extend(Some(v1434));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                    let v1437 = C::ty_smax(ctx, v166.0);
                                                    let v1438 = C::u64_eq(ctx, v217, v1437);
                                                    if v1438 == true {
                                                        let v1427 = constructor_ne(ctx, v1425, v155.0, v155.1);
                                                        // Rule at src/opts/icmp.isle line 159.
                                                        returns.extend(Some(v1427));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                            }
                            let v297 = C::ty_int(ctx, v2.0);
                            if let Some(v298) = v297 {
                                if v155.0 == v155.1 {
                                    let v299 = constructor_iconst_u(ctx, v298, 0x0_u64);
                                    let v300 = C::subsume(ctx, v299);
                                    // Rule at src/opts/icmp.isle line 12.
                                    returns.extend(Some(v300));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                            let mut v1326 = C::inst_data_value_tupled_etor_returns::default();
                            C::inst_data_value_tupled_etor(ctx, v155.1, &mut v1326);
                            let mut v1326 = v1326.into_context_iter();
                            while let Some(v1327) = v1326.next(ctx) {
                                let v1328 = C::iconst_sextend_etor(ctx, v1327);
                                if let Some(v1329) = v1328 {
                                    if v1329.1 == 1_i64 {
                                        let v1449 = constructor_iconst_s(ctx, v1329.0, 0_i64);
                                        let v1451 = constructor_sle(ctx, v2.0, v155.0, v1449);
                                        // Rule at src/opts/icmp.isle line 198.
                                        returns.extend(Some(v1451));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                            }
                        }
                        &IntCC::SignedLessThanOrEqual => {
                            let v155 = C::unpack_value_array_2(ctx, v153);
                            let mut v158 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v155.0, &mut v158);
                            let mut v158 = v158.into_context_iter();
                            while let Some(v159) = v158.next(ctx) {
                                if let &InstructionData::Binary {
                                    opcode: ref v203,
                                    args: ref v204,
                                } = &v159.1 {
                                    match v203 {
                                        &Opcode::Smin => {
                                            if v2.0 == v159.0 {
                                                let v205 = C::unpack_value_array_2(ctx, v204);
                                                if v155.1 == v205.0 {
                                                    let v275 = constructor_cmp_true(ctx, v2.0);
                                                    // Rule at src/opts/arithmetic.isle line 363.
                                                    returns.extend(Some(v275));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v155.1 == v205.1 {
                                                    let v275 = constructor_cmp_true(ctx, v2.0);
                                                    // Rule at src/opts/arithmetic.isle line 364.
                                                    returns.extend(Some(v275));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        &Opcode::Isub => {
                                            if v159.0 == I8 {
                                                let v205 = C::unpack_value_array_2(ctx, v204);
                                                let mut v208 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v205.1, &mut v208);
                                                let mut v208 = v208.into_context_iter();
                                                while let Some(v209) = v208.next(ctx) {
                                                    if let &InstructionData::IntCompare {
                                                        opcode: ref v1933,
                                                        args: ref v1934,
                                                        cond: ref v1935,
                                                    } = &v209.1 {
                                                        if let &Opcode::Icmp = v1933 {
                                                            match v1935 {
                                                                &IntCC::SignedLessThan => {
                                                                    let mut v225 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v205.0, &mut v225);
                                                                    let mut v225 = v225.into_context_iter();
                                                                    while let Some(v226) = v225.next(ctx) {
                                                                        if let &InstructionData::IntCompare {
                                                                            opcode: ref v1927,
                                                                            args: ref v1928,
                                                                            cond: ref v1929,
                                                                        } = &v226.1 {
                                                                            if let &Opcode::Icmp = v1927 {
                                                                                if let &IntCC::SignedGreaterThan = v1929 {
                                                                                    if v209.0 == v226.0 {
                                                                                        let v1930 = C::unpack_value_array_2(ctx, v1928);
                                                                                        let v1936 = C::unpack_value_array_2(ctx, v1934);
                                                                                        if v1930.0 == v1936.0 {
                                                                                            if v1930.1 == v1936.1 {
                                                                                                let mut v1326 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                C::inst_data_value_tupled_etor(ctx, v155.1, &mut v1326);
                                                                                                let mut v1326 = v1326.into_context_iter();
                                                                                                while let Some(v1327) = v1326.next(ctx) {
                                                                                                    let v1328 = C::iconst_sextend_etor(ctx, v1327);
                                                                                                    if let Some(v1329) = v1328 {
                                                                                                        if v1329.1 == 0_i64 {
                                                                                                            let v1943 = constructor_sle(ctx, v226.0, v1930.0, v1930.1);
                                                                                                            // Rule at src/opts/spaceship.isle line 161.
                                                                                                            returns.extend(Some(v1943));
                                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &IntCC::UnsignedLessThan => {
                                                                    let mut v225 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v205.0, &mut v225);
                                                                    let mut v225 = v225.into_context_iter();
                                                                    while let Some(v226) = v225.next(ctx) {
                                                                        if let &InstructionData::IntCompare {
                                                                            opcode: ref v1927,
                                                                            args: ref v1928,
                                                                            cond: ref v1929,
                                                                        } = &v226.1 {
                                                                            if let &Opcode::Icmp = v1927 {
                                                                                if let &IntCC::UnsignedGreaterThan = v1929 {
                                                                                    if v209.0 == v226.0 {
                                                                                        let v1930 = C::unpack_value_array_2(ctx, v1928);
                                                                                        let v1936 = C::unpack_value_array_2(ctx, v1934);
                                                                                        if v1930.0 == v1936.0 {
                                                                                            if v1930.1 == v1936.1 {
                                                                                                let mut v1326 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                C::inst_data_value_tupled_etor(ctx, v155.1, &mut v1326);
                                                                                                let mut v1326 = v1326.into_context_iter();
                                                                                                while let Some(v1327) = v1326.next(ctx) {
                                                                                                    let v1328 = C::iconst_sextend_etor(ctx, v1327);
                                                                                                    if let Some(v1329) = v1328 {
                                                                                                        if v1329.1 == 0_i64 {
                                                                                                            let v1944 = constructor_ule(ctx, v226.0, v1930.0, v1930.1);
                                                                                                            // Rule at src/opts/spaceship.isle line 163.
                                                                                                            returns.extend(Some(v1944));
                                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                            }
                            let mut v165 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v155.1, &mut v165);
                            let mut v165 = v165.into_context_iter();
                            while let Some(v166) = v165.next(ctx) {
                                match &v166.1 {
                                    &InstructionData::Binary {
                                        opcode: ref v169,
                                        args: ref v170,
                                    } => {
                                        if let &Opcode::Smax = v169 {
                                            if v2.0 == v166.0 {
                                                let v171 = C::unpack_value_array_2(ctx, v170);
                                                if v155.0 == v171.0 {
                                                    let v275 = constructor_cmp_true(ctx, v2.0);
                                                    // Rule at src/opts/arithmetic.isle line 353.
                                                    returns.extend(Some(v275));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v155.0 == v171.1 {
                                                    let v275 = constructor_cmp_true(ctx, v2.0);
                                                    // Rule at src/opts/arithmetic.isle line 354.
                                                    returns.extend(Some(v275));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                    &InstructionData::UnaryImm {
                                        opcode: ref v215,
                                        imm: v216,
                                    } => {
                                        if let &Opcode::Iconst = v215 {
                                            let v292 = C::fits_in_64(ctx, v2.0);
                                            if let Some(v293) = v292 {
                                                let v1424 = C::ty_int(ctx, v293);
                                                if let Some(v1425) = v1424 {
                                                    let v217 = C::u64_from_imm64(ctx, v216);
                                                    let v1435 = C::ty_smin(ctx, v166.0);
                                                    let v1436 = C::u64_eq(ctx, v217, v1435);
                                                    if v1436 == true {
                                                        let v1426 = constructor_eq(ctx, v1425, v155.0, v155.1);
                                                        // Rule at src/opts/icmp.isle line 144.
                                                        returns.extend(Some(v1426));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                    let v1437 = C::ty_smax(ctx, v166.0);
                                                    let v1438 = C::u64_eq(ctx, v217, v1437);
                                                    if v1438 == true {
                                                        let v1431 = constructor_iconst_u(ctx, v1425, 0x1_u64);
                                                        let v1432 = C::subsume(ctx, v1431);
                                                        // Rule at src/opts/icmp.isle line 164.
                                                        returns.extend(Some(v1432));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                            if v155.0 == v155.1 {
                                let v297 = C::ty_int(ctx, v2.0);
                                if let Some(v298) = v297 {
                                    let v1369 = constructor_iconst_u(ctx, v298, 0x1_u64);
                                    let v1370 = C::subsume(ctx, v1369);
                                    // Rule at src/opts/icmp.isle line 13.
                                    returns.extend(Some(v1370));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                            let mut v1326 = C::inst_data_value_tupled_etor_returns::default();
                            C::inst_data_value_tupled_etor(ctx, v155.1, &mut v1326);
                            let mut v1326 = v1326.into_context_iter();
                            while let Some(v1327) = v1326.next(ctx) {
                                let v1328 = C::iconst_sextend_etor(ctx, v1327);
                                if let Some(v1329) = v1328 {
                                    if v1329.1 == -1_i64 {
                                        let v1449 = constructor_iconst_s(ctx, v1329.0, 0_i64);
                                        let v1453 = constructor_slt(ctx, v2.0, v155.0, v1449);
                                        // Rule at src/opts/icmp.isle line 204.
                                        returns.extend(Some(v1453));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                            }
                        }
                        &IntCC::UnsignedGreaterThan => {
                            let v292 = C::fits_in_64(ctx, v2.0);
                            if let Some(v293) = v292 {
                                let v1424 = C::ty_int(ctx, v293);
                                if let Some(v1425) = v1424 {
                                    let v155 = C::unpack_value_array_2(ctx, v153);
                                    let mut v165 = C::inst_data_value_etor_returns::default();
                                    C::inst_data_value_etor(ctx, v155.1, &mut v165);
                                    let mut v165 = v165.into_context_iter();
                                    while let Some(v166) = v165.next(ctx) {
                                        if let &InstructionData::UnaryImm {
                                            opcode: ref v215,
                                            imm: v216,
                                        } = &v166.1 {
                                            if let &Opcode::Iconst = v215 {
                                                let v217 = C::u64_from_imm64(ctx, v216);
                                                if v217 == 0x0_u64 {
                                                    let v1427 = constructor_ne(ctx, v1425, v155.0, v155.1);
                                                    // Rule at src/opts/icmp.isle line 111.
                                                    returns.extend(Some(v1427));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let v1429 = C::ty_umax(ctx, v166.0);
                                                let v1430 = C::u64_eq(ctx, v217, v1429);
                                                if v1430 == true {
                                                    let v1433 = constructor_iconst_u(ctx, v1425, 0x0_u64);
                                                    let v1434 = C::subsume(ctx, v1433);
                                                    // Rule at src/opts/icmp.isle line 129.
                                                    returns.extend(Some(v1434));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                                let v155 = C::unpack_value_array_2(ctx, v153);
                                let mut v158 = C::inst_data_value_etor_returns::default();
                                C::inst_data_value_etor(ctx, v155.0, &mut v158);
                                let mut v158 = v158.into_context_iter();
                                while let Some(v159) = v158.next(ctx) {
                                    if let &InstructionData::Binary {
                                        opcode: ref v203,
                                        args: ref v204,
                                    } = &v159.1 {
                                        if let &Opcode::Umin = v203 {
                                            let v205 = C::unpack_value_array_2(ctx, v204);
                                            if v155.1 == v205.0 {
                                                let v1673 = constructor_iconst_u(ctx, v293, 0x0_u64);
                                                // Rule at src/opts/selects.isle line 109.
                                                returns.extend(Some(v1673));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            if v155.1 == v205.1 {
                                                let v1673 = constructor_iconst_u(ctx, v293, 0x0_u64);
                                                // Rule at src/opts/selects.isle line 110.
                                                returns.extend(Some(v1673));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                }
                            }
                            let v155 = C::unpack_value_array_2(ctx, v153);
                            let mut v165 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v155.1, &mut v165);
                            let mut v165 = v165.into_context_iter();
                            while let Some(v166) = v165.next(ctx) {
                                if let &InstructionData::Binary {
                                    opcode: ref v169,
                                    args: ref v170,
                                } = &v166.1 {
                                    if let &Opcode::Umax = v169 {
                                        if v2.0 == v166.0 {
                                            let v171 = C::unpack_value_array_2(ctx, v170);
                                            if v155.0 == v171.0 {
                                                let v53 = constructor_iconst_u(ctx, v2.0, 0x0_u64);
                                                // Rule at src/opts/arithmetic.isle line 501.
                                                returns.extend(Some(v53));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            if v155.0 == v171.1 {
                                                let v53 = constructor_iconst_u(ctx, v2.0, 0x0_u64);
                                                // Rule at src/opts/arithmetic.isle line 502.
                                                returns.extend(Some(v53));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                }
                            }
                            let v297 = C::ty_int(ctx, v2.0);
                            if let Some(v298) = v297 {
                                if v155.0 == v155.1 {
                                    let v299 = constructor_iconst_u(ctx, v298, 0x0_u64);
                                    let v300 = C::subsume(ctx, v299);
                                    // Rule at src/opts/icmp.isle line 6.
                                    returns.extend(Some(v300));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                            let mut v158 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v155.0, &mut v158);
                            let mut v158 = v158.into_context_iter();
                            while let Some(v159) = v158.next(ctx) {
                                if let &InstructionData::Binary {
                                    opcode: ref v203,
                                    args: ref v204,
                                } = &v159.1 {
                                    if let &Opcode::Isub = v203 {
                                        let v205 = C::unpack_value_array_2(ctx, v204);
                                        if v155.1 == v205.0 {
                                            let v1497 = constructor_ugt(ctx, v2.0, v205.1, v205.0);
                                            // Rule at src/opts/icmp.isle line 298.
                                            returns.extend(Some(v1497));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                            }
                        }
                        &IntCC::UnsignedGreaterThanOrEqual => {
                            let v155 = C::unpack_value_array_2(ctx, v153);
                            let mut v165 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v155.1, &mut v165);
                            let mut v165 = v165.into_context_iter();
                            while let Some(v166) = v165.next(ctx) {
                                match &v166.1 {
                                    &InstructionData::Binary {
                                        opcode: ref v169,
                                        args: ref v170,
                                    } => {
                                        match v169 {
                                            &Opcode::Umin => {
                                                if v2.0 == v166.0 {
                                                    let v171 = C::unpack_value_array_2(ctx, v170);
                                                    if v155.0 == v171.0 {
                                                        let v275 = constructor_cmp_true(ctx, v2.0);
                                                        // Rule at src/opts/arithmetic.isle line 365.
                                                        returns.extend(Some(v275));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                    if v155.0 == v171.1 {
                                                        let v275 = constructor_cmp_true(ctx, v2.0);
                                                        // Rule at src/opts/arithmetic.isle line 366.
                                                        returns.extend(Some(v275));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &Opcode::Band => {
                                                if v2.0 == v166.0 {
                                                    let v171 = C::unpack_value_array_2(ctx, v170);
                                                    if v155.0 == v171.0 {
                                                        let v275 = constructor_cmp_true(ctx, v2.0);
                                                        // Rule at src/opts/bitops.isle line 661.
                                                        returns.extend(Some(v275));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                    if v155.0 == v171.1 {
                                                        let v275 = constructor_cmp_true(ctx, v2.0);
                                                        // Rule at src/opts/bitops.isle line 662.
                                                        returns.extend(Some(v275));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                    &InstructionData::UnaryImm {
                                        opcode: ref v215,
                                        imm: v216,
                                    } => {
                                        if let &Opcode::Iconst = v215 {
                                            let v217 = C::u64_from_imm64(ctx, v216);
                                            match v217 {
                                                0x0_u64 => {
                                                    let v275 = constructor_cmp_true(ctx, v2.0);
                                                    let v1428 = C::subsume(ctx, v275);
                                                    // Rule at src/opts/icmp.isle line 115.
                                                    returns.extend(Some(v1428));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                0x1_u64 => {
                                                    let v252 = constructor_iconst_u(ctx, v166.0, 0x0_u64);
                                                    let v1447 = constructor_ne(ctx, v2.0, v155.0, v252);
                                                    // Rule at src/opts/icmp.isle line 189.
                                                    returns.extend(Some(v1447));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                _ => {}
                                            }
                                            let v292 = C::fits_in_64(ctx, v2.0);
                                            if let Some(v293) = v292 {
                                                let v1424 = C::ty_int(ctx, v293);
                                                if let Some(v1425) = v1424 {
                                                    let v1429 = C::ty_umax(ctx, v166.0);
                                                    let v1430 = C::u64_eq(ctx, v217, v1429);
                                                    if v1430 == true {
                                                        let v1426 = constructor_eq(ctx, v1425, v155.0, v155.1);
                                                        // Rule at src/opts/icmp.isle line 134.
                                                        returns.extend(Some(v1426));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                            let mut v158 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v155.0, &mut v158);
                            let mut v158 = v158.into_context_iter();
                            while let Some(v159) = v158.next(ctx) {
                                if let &InstructionData::Binary {
                                    opcode: ref v203,
                                    args: ref v204,
                                } = &v159.1 {
                                    match v203 {
                                        &Opcode::Umax => {
                                            if v2.0 == v159.0 {
                                                let v205 = C::unpack_value_array_2(ctx, v204);
                                                if v155.1 == v205.0 {
                                                    let v275 = constructor_cmp_true(ctx, v2.0);
                                                    // Rule at src/opts/arithmetic.isle line 355.
                                                    returns.extend(Some(v275));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v155.1 == v205.1 {
                                                    let v275 = constructor_cmp_true(ctx, v2.0);
                                                    // Rule at src/opts/arithmetic.isle line 356.
                                                    returns.extend(Some(v275));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        &Opcode::Bor => {
                                            if v2.0 == v159.0 {
                                                let v205 = C::unpack_value_array_2(ctx, v204);
                                                if v155.1 == v205.0 {
                                                    let v275 = constructor_cmp_true(ctx, v2.0);
                                                    // Rule at src/opts/bitops.isle line 667.
                                                    returns.extend(Some(v275));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v155.1 == v205.1 {
                                                    let v275 = constructor_cmp_true(ctx, v2.0);
                                                    // Rule at src/opts/bitops.isle line 668.
                                                    returns.extend(Some(v275));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                            }
                            if v155.0 == v155.1 {
                                let v297 = C::ty_int(ctx, v2.0);
                                if let Some(v298) = v297 {
                                    let v1369 = constructor_iconst_u(ctx, v298, 0x1_u64);
                                    let v1370 = C::subsume(ctx, v1369);
                                    // Rule at src/opts/icmp.isle line 7.
                                    returns.extend(Some(v1370));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                        }
                        &IntCC::UnsignedLessThan => {
                            let v155 = C::unpack_value_array_2(ctx, v153);
                            let mut v165 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v155.1, &mut v165);
                            let mut v165 = v165.into_context_iter();
                            while let Some(v166) = v165.next(ctx) {
                                match &v166.1 {
                                    &InstructionData::Binary {
                                        opcode: ref v169,
                                        args: ref v170,
                                    } => {
                                        if let &Opcode::Umin = v169 {
                                            let v292 = C::fits_in_64(ctx, v2.0);
                                            if let Some(v293) = v292 {
                                                let v171 = C::unpack_value_array_2(ctx, v170);
                                                if v155.0 == v171.0 {
                                                    let v1673 = constructor_iconst_u(ctx, v293, 0x0_u64);
                                                    // Rule at src/opts/selects.isle line 111.
                                                    returns.extend(Some(v1673));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v155.0 == v171.1 {
                                                    let v1673 = constructor_iconst_u(ctx, v293, 0x0_u64);
                                                    // Rule at src/opts/selects.isle line 112.
                                                    returns.extend(Some(v1673));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                    &InstructionData::Unary {
                                        opcode: ref v258,
                                        arg: v259,
                                    } => {
                                        if let &Opcode::Bnot = v258 {
                                            let mut v158 = C::inst_data_value_etor_returns::default();
                                            C::inst_data_value_etor(ctx, v155.0, &mut v158);
                                            let mut v158 = v158.into_context_iter();
                                            while let Some(v159) = v158.next(ctx) {
                                                if let &InstructionData::Unary {
                                                    opcode: ref v256,
                                                    arg: v257,
                                                } = &v159.1 {
                                                    if let &Opcode::Bnot = v256 {
                                                        if v159.0 == v166.0 {
                                                            let v1517 = constructor_ugt(ctx, v2.0, v257, v259);
                                                            // Rule at src/opts/icmp.isle line 305.
                                                            returns.extend(Some(v1517));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    &InstructionData::UnaryImm {
                                        opcode: ref v215,
                                        imm: v216,
                                    } => {
                                        if let &Opcode::Iconst = v215 {
                                            let v217 = C::u64_from_imm64(ctx, v216);
                                            match v217 {
                                                0x0_u64 => {
                                                    let v53 = constructor_iconst_u(ctx, v2.0, 0x0_u64);
                                                    let v54 = C::subsume(ctx, v53);
                                                    // Rule at src/opts/icmp.isle line 103.
                                                    returns.extend(Some(v54));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                0x1_u64 => {
                                                    let v252 = constructor_iconst_u(ctx, v166.0, 0x0_u64);
                                                    let v1448 = constructor_eq(ctx, v2.0, v155.0, v252);
                                                    // Rule at src/opts/icmp.isle line 192.
                                                    returns.extend(Some(v1448));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                _ => {}
                                            }
                                            let v292 = C::fits_in_64(ctx, v2.0);
                                            if let Some(v293) = v292 {
                                                let v1424 = C::ty_int(ctx, v293);
                                                if let Some(v1425) = v1424 {
                                                    let v1429 = C::ty_umax(ctx, v166.0);
                                                    let v1430 = C::u64_eq(ctx, v217, v1429);
                                                    if v1430 == true {
                                                        let v1427 = constructor_ne(ctx, v1425, v155.0, v155.1);
                                                        // Rule at src/opts/icmp.isle line 119.
                                                        returns.extend(Some(v1427));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                            let mut v158 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v155.0, &mut v158);
                            let mut v158 = v158.into_context_iter();
                            while let Some(v159) = v158.next(ctx) {
                                if let &InstructionData::Binary {
                                    opcode: ref v203,
                                    args: ref v204,
                                } = &v159.1 {
                                    if let &Opcode::Umax = v203 {
                                        if v2.0 == v159.0 {
                                            let v205 = C::unpack_value_array_2(ctx, v204);
                                            if v155.1 == v205.0 {
                                                let v53 = constructor_iconst_u(ctx, v2.0, 0x0_u64);
                                                // Rule at src/opts/arithmetic.isle line 503.
                                                returns.extend(Some(v53));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            if v155.1 == v205.1 {
                                                let v53 = constructor_iconst_u(ctx, v2.0, 0x0_u64);
                                                // Rule at src/opts/arithmetic.isle line 504.
                                                returns.extend(Some(v53));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                }
                            }
                            if v155.0 == v155.1 {
                                let v297 = C::ty_int(ctx, v2.0);
                                if let Some(v298) = v297 {
                                    let v299 = constructor_iconst_u(ctx, v298, 0x0_u64);
                                    let v300 = C::subsume(ctx, v299);
                                    // Rule at src/opts/icmp.isle line 10.
                                    returns.extend(Some(v300));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                        }
                        &IntCC::UnsignedLessThanOrEqual => {
                            let v155 = C::unpack_value_array_2(ctx, v153);
                            let mut v165 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v155.1, &mut v165);
                            let mut v165 = v165.into_context_iter();
                            while let Some(v166) = v165.next(ctx) {
                                match &v166.1 {
                                    &InstructionData::Binary {
                                        opcode: ref v169,
                                        args: ref v170,
                                    } => {
                                        match v169 {
                                            &Opcode::Umax => {
                                                if v2.0 == v166.0 {
                                                    let v171 = C::unpack_value_array_2(ctx, v170);
                                                    if v155.0 == v171.0 {
                                                        let v275 = constructor_cmp_true(ctx, v2.0);
                                                        // Rule at src/opts/arithmetic.isle line 357.
                                                        returns.extend(Some(v275));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                    if v155.0 == v171.1 {
                                                        let v275 = constructor_cmp_true(ctx, v2.0);
                                                        // Rule at src/opts/arithmetic.isle line 358.
                                                        returns.extend(Some(v275));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &Opcode::Bor => {
                                                if v2.0 == v166.0 {
                                                    let v171 = C::unpack_value_array_2(ctx, v170);
                                                    if v155.0 == v171.0 {
                                                        let v275 = constructor_cmp_true(ctx, v2.0);
                                                        // Rule at src/opts/bitops.isle line 669.
                                                        returns.extend(Some(v275));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                    if v155.0 == v171.1 {
                                                        let v275 = constructor_cmp_true(ctx, v2.0);
                                                        // Rule at src/opts/bitops.isle line 670.
                                                        returns.extend(Some(v275));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                    &InstructionData::UnaryImm {
                                        opcode: ref v215,
                                        imm: v216,
                                    } => {
                                        if let &Opcode::Iconst = v215 {
                                            let v292 = C::fits_in_64(ctx, v2.0);
                                            if let Some(v293) = v292 {
                                                let v1424 = C::ty_int(ctx, v293);
                                                if let Some(v1425) = v1424 {
                                                    let v217 = C::u64_from_imm64(ctx, v216);
                                                    if v217 == 0x0_u64 {
                                                        let v1426 = constructor_eq(ctx, v1425, v155.0, v155.1);
                                                        // Rule at src/opts/icmp.isle line 107.
                                                        returns.extend(Some(v1426));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                    let v1429 = C::ty_umax(ctx, v166.0);
                                                    let v1430 = C::u64_eq(ctx, v217, v1429);
                                                    if v1430 == true {
                                                        let v1431 = constructor_iconst_u(ctx, v1425, 0x1_u64);
                                                        let v1432 = C::subsume(ctx, v1431);
                                                        // Rule at src/opts/icmp.isle line 124.
                                                        returns.extend(Some(v1432));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                            let mut v158 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v155.0, &mut v158);
                            let mut v158 = v158.into_context_iter();
                            while let Some(v159) = v158.next(ctx) {
                                if let &InstructionData::Binary {
                                    opcode: ref v203,
                                    args: ref v204,
                                } = &v159.1 {
                                    match v203 {
                                        &Opcode::Umin => {
                                            if v2.0 == v159.0 {
                                                let v205 = C::unpack_value_array_2(ctx, v204);
                                                if v155.1 == v205.0 {
                                                    let v275 = constructor_cmp_true(ctx, v2.0);
                                                    // Rule at src/opts/arithmetic.isle line 367.
                                                    returns.extend(Some(v275));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v155.1 == v205.1 {
                                                    let v275 = constructor_cmp_true(ctx, v2.0);
                                                    // Rule at src/opts/arithmetic.isle line 368.
                                                    returns.extend(Some(v275));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        &Opcode::Isub => {
                                            let v205 = C::unpack_value_array_2(ctx, v204);
                                            if v155.1 == v205.0 {
                                                let v1498 = constructor_ule(ctx, v2.0, v205.1, v205.0);
                                                // Rule at src/opts/icmp.isle line 299.
                                                returns.extend(Some(v1498));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        &Opcode::Band => {
                                            if v2.0 == v159.0 {
                                                let v205 = C::unpack_value_array_2(ctx, v204);
                                                if v155.1 == v205.0 {
                                                    let v275 = constructor_cmp_true(ctx, v2.0);
                                                    // Rule at src/opts/bitops.isle line 663.
                                                    returns.extend(Some(v275));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v155.1 == v205.1 {
                                                    let v275 = constructor_cmp_true(ctx, v2.0);
                                                    // Rule at src/opts/bitops.isle line 664.
                                                    returns.extend(Some(v275));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                            }
                            if v155.0 == v155.1 {
                                let v297 = C::ty_int(ctx, v2.0);
                                if let Some(v298) = v297 {
                                    let v1369 = constructor_iconst_u(ctx, v298, 0x1_u64);
                                    let v1370 = C::subsume(ctx, v1369);
                                    // Rule at src/opts/icmp.isle line 11.
                                    returns.extend(Some(v1370));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                        }
                        _ => {}
                    }
                    let v155 = C::unpack_value_array_2(ctx, v153);
                    let mut v158 = C::inst_data_value_etor_returns::default();
                    C::inst_data_value_etor(ctx, v155.0, &mut v158);
                    let mut v158 = v158.into_context_iter();
                    while let Some(v159) = v158.next(ctx) {
                        match &v159.1 {
                            &InstructionData::Unary {
                                opcode: ref v256,
                                arg: v257,
                            } => {
                                if let &Opcode::Sextend = v256 {
                                    let v1336 = &C::signed_cond_code(ctx, v154);
                                    if let Some(v1337) = v1336 {
                                        let mut v1326 = C::inst_data_value_tupled_etor_returns::default();
                                        C::inst_data_value_tupled_etor(ctx, v155.1, &mut v1326);
                                        let mut v1326 = v1326.into_context_iter();
                                        while let Some(v1327) = v1326.next(ctx) {
                                            let v1328 = C::iconst_sextend_etor(ctx, v1327);
                                            if let Some(v1329) = v1328 {
                                                if v1329.1 == 0_i64 {
                                                    let v1322 = C::value_type(ctx, v257);
                                                    let v1333 = constructor_iconst_s(ctx, v1322, 0_i64);
                                                    let v1338 = constructor_icmp(ctx, v1322, v154, v257, v1333);
                                                    // Rule at src/opts/extends.isle line 43.
                                                    returns.extend(Some(v1338));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            &InstructionData::UnaryImm {
                                opcode: ref v162,
                                imm: v163,
                            } => {
                                if let &Opcode::Iconst = v162 {
                                    let mut v165 = C::inst_data_value_etor_returns::default();
                                    C::inst_data_value_etor(ctx, v155.1, &mut v165);
                                    let mut v165 = v165.into_context_iter();
                                    while let Some(v166) = v165.next(ctx) {
                                        if let &InstructionData::UnaryImm {
                                            opcode: ref v215,
                                            imm: v216,
                                        } = &v166.1 {
                                            if let &Opcode::Iconst = v215 {
                                                if v159.0 == v166.0 {
                                                    let v989 = C::imm64_icmp(ctx, v159.0, v154, v163, v216);
                                                    let v990 = constructor_iconst(ctx, v2.0, v989);
                                                    let v991 = C::subsume(ctx, v990);
                                                    // Rule at src/opts/cprop.isle line 134.
                                                    returns.extend(Some(v991));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                    let v1003 = &C::intcc_swap_args(ctx, v154);
                                    let v1004 = constructor_icmp(ctx, v2.0, v1003, v155.1, v155.0);
                                    // Rule at src/opts/cprop.isle line 173.
                                    returns.extend(Some(v1004));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                            _ => {}
                        }
                    }
                }
            }
            &InstructionData::Ternary {
                opcode: ref v82,
                args: ref v83,
            } => {
                match v82 {
                    &Opcode::Select => {
                        let v84 = C::unpack_value_array_3(ctx, v83);
                        let mut v88 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v84.0, &mut v88);
                        let mut v88 = v88.into_context_iter();
                        while let Some(v89) = v88.next(ctx) {
                            match &v89.1 {
                                &InstructionData::Binary {
                                    opcode: ref v1676,
                                    args: ref v1677,
                                } => {
                                    if let &Opcode::Bor = v1676 {
                                        let v1678 = C::unpack_value_array_2(ctx, v1677);
                                        let mut v1681 = C::inst_data_value_etor_returns::default();
                                        C::inst_data_value_etor(ctx, v1678.1, &mut v1681);
                                        let mut v1681 = v1681.into_context_iter();
                                        while let Some(v1682) = v1681.next(ctx) {
                                            if let &InstructionData::IntCompare {
                                                opcode: ref v1685,
                                                args: ref v1686,
                                                cond: ref v1687,
                                            } = &v1682.1 {
                                                if let &Opcode::Icmp = v1685 {
                                                    if let &IntCC::NotEqual = v1687 {
                                                        if v89.0 == v1682.0 {
                                                            let v1688 = C::unpack_value_array_2(ctx, v1686);
                                                            if v84.1 == v1688.0 {
                                                                if v84.2 == v1688.1 {
                                                                    let v1691 = C::subsume(ctx, v1688.0);
                                                                    // Rule at src/opts/selects.isle line 122.
                                                                    returns.extend(Some(v1691));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                            if v84.1 == v1688.1 {
                                                                if v84.2 == v1688.0 {
                                                                    let v1703 = C::subsume(ctx, v1688.1);
                                                                    // Rule at src/opts/selects.isle line 124.
                                                                    returns.extend(Some(v1703));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        let mut v1692 = C::inst_data_value_etor_returns::default();
                                        C::inst_data_value_etor(ctx, v1678.0, &mut v1692);
                                        let mut v1692 = v1692.into_context_iter();
                                        while let Some(v1693) = v1692.next(ctx) {
                                            if let &InstructionData::IntCompare {
                                                opcode: ref v1696,
                                                args: ref v1697,
                                                cond: ref v1698,
                                            } = &v1693.1 {
                                                if let &Opcode::Icmp = v1696 {
                                                    if let &IntCC::NotEqual = v1698 {
                                                        if v89.0 == v1693.0 {
                                                            let v1699 = C::unpack_value_array_2(ctx, v1697);
                                                            if v84.1 == v1699.0 {
                                                                if v84.2 == v1699.1 {
                                                                    let v1702 = C::subsume(ctx, v1699.0);
                                                                    // Rule at src/opts/selects.isle line 123.
                                                                    returns.extend(Some(v1702));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                            if v84.1 == v1699.1 {
                                                                if v84.2 == v1699.0 {
                                                                    let v1704 = C::subsume(ctx, v1699.1);
                                                                    // Rule at src/opts/selects.isle line 125.
                                                                    returns.extend(Some(v1704));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::IntCompare {
                                    opcode: ref v1454,
                                    args: ref v1455,
                                    cond: ref v1456,
                                } => {
                                    if let &Opcode::Icmp = v1454 {
                                        match v1456 {
                                            &IntCC::Equal => {
                                                let mut v1470 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v84.2, &mut v1470);
                                                let mut v1470 = v1470.into_context_iter();
                                                while let Some(v1471) = v1470.next(ctx) {
                                                    match &v1471.1 {
                                                        &InstructionData::Binary {
                                                            opcode: ref v1705,
                                                            args: ref v1706,
                                                        } => {
                                                            match v1705 {
                                                                &Opcode::Isub => {
                                                                    if v2.0 == v1471.0 {
                                                                        let mut v94 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v84.1, &mut v94);
                                                                        let mut v94 = v94.into_context_iter();
                                                                        while let Some(v95) = v94.next(ctx) {
                                                                            if let &InstructionData::Binary {
                                                                                opcode: ref v1711,
                                                                                args: ref v1712,
                                                                            } = &v95.1 {
                                                                                if let &Opcode::Isub = v1711 {
                                                                                    if v2.0 == v95.0 {
                                                                                        let v1707 = C::unpack_value_array_2(ctx, v1706);
                                                                                        let v1713 = C::unpack_value_array_2(ctx, v1712);
                                                                                        if v1707.0 == v1713.0 {
                                                                                            let mut v1725 = C::inst_data_value_etor_returns::default();
                                                                                            C::inst_data_value_etor(ctx, v1713.1, &mut v1725);
                                                                                            let mut v1725 = v1725.into_context_iter();
                                                                                            while let Some(v1726) = v1725.next(ctx) {
                                                                                                if let &InstructionData::UnaryImm {
                                                                                                    opcode: ref v1729,
                                                                                                    imm: v1730,
                                                                                                } = &v1726.1 {
                                                                                                    if let &Opcode::Iconst = v1729 {
                                                                                                        if v2.0 == v1726.0 {
                                                                                                            let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                                                            if v1457.0 == v1707.1 {
                                                                                                                let mut v1627 = C::inst_data_value_etor_returns::default();
                                                                                                                C::inst_data_value_etor(ctx, v1457.1, &mut v1627);
                                                                                                                let mut v1627 = v1627.into_context_iter();
                                                                                                                while let Some(v1628) = v1627.next(ctx) {
                                                                                                                    if let &InstructionData::UnaryImm {
                                                                                                                        opcode: ref v1631,
                                                                                                                        imm: v1632,
                                                                                                                    } = &v1628.1 {
                                                                                                                        if let &Opcode::Iconst = v1631 {
                                                                                                                            if v2.0 == v1628.0 {
                                                                                                                                let v1633 = C::u64_from_imm64(ctx, v1632);
                                                                                                                                let v1731 = C::u64_from_imm64(ctx, v1730);
                                                                                                                                if v1633 == v1731 {
                                                                                                                                    let v1732 = constructor_isub(ctx, v2.0, v1713.0, v1457.0);
                                                                                                                                    // Rule at src/opts/selects.isle line 185.
                                                                                                                                    returns.extend(Some(v1732));
                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                            if v1457.1 == v1707.1 {
                                                                                                                let mut v1740 = C::inst_data_value_etor_returns::default();
                                                                                                                C::inst_data_value_etor(ctx, v1457.0, &mut v1740);
                                                                                                                let mut v1740 = v1740.into_context_iter();
                                                                                                                while let Some(v1741) = v1740.next(ctx) {
                                                                                                                    if let &InstructionData::UnaryImm {
                                                                                                                        opcode: ref v1744,
                                                                                                                        imm: v1745,
                                                                                                                    } = &v1741.1 {
                                                                                                                        if let &Opcode::Iconst = v1744 {
                                                                                                                            if v2.0 == v1741.0 {
                                                                                                                                let v1731 = C::u64_from_imm64(ctx, v1730);
                                                                                                                                let v1746 = C::u64_from_imm64(ctx, v1745);
                                                                                                                                if v1731 == v1746 {
                                                                                                                                    let v1747 = constructor_isub(ctx, v2.0, v1713.0, v1457.1);
                                                                                                                                    // Rule at src/opts/selects.isle line 187.
                                                                                                                                    returns.extend(Some(v1747));
                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Band => {
                                                                    if v2.0 == v1471.0 {
                                                                        let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                        if v84.1 == v1457.0 {
                                                                            let v1707 = C::unpack_value_array_2(ctx, v1706);
                                                                            if v84.1 == v1707.0 {
                                                                                if v1457.1 == v1707.1 {
                                                                                    let v1718 = constructor_band(ctx, v2.0, v1457.1, v1457.0);
                                                                                    // Rule at src/opts/selects.isle line 147.
                                                                                    returns.extend(Some(v1718));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                            if v84.1 == v1707.1 {
                                                                                if v1457.1 == v1707.0 {
                                                                                    let v1718 = constructor_band(ctx, v2.0, v1457.1, v1457.0);
                                                                                    // Rule at src/opts/selects.isle line 145.
                                                                                    returns.extend(Some(v1718));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                        if v84.1 == v1457.1 {
                                                                            let v1707 = C::unpack_value_array_2(ctx, v1706);
                                                                            if v84.1 == v1707.0 {
                                                                                if v1457.0 == v1707.1 {
                                                                                    let v1717 = constructor_band(ctx, v2.0, v1457.0, v1457.1);
                                                                                    // Rule at src/opts/selects.isle line 143.
                                                                                    returns.extend(Some(v1717));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                            if v1457.0 == v1707.0 {
                                                                                if v84.1 == v1707.1 {
                                                                                    let v1717 = constructor_band(ctx, v2.0, v1457.0, v1457.1);
                                                                                    // Rule at src/opts/selects.isle line 141.
                                                                                    returns.extend(Some(v1717));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Bor => {
                                                                    if v2.0 == v1471.0 {
                                                                        let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                        if v84.1 == v1457.0 {
                                                                            let v1707 = C::unpack_value_array_2(ctx, v1706);
                                                                            if v84.1 == v1707.0 {
                                                                                if v1457.1 == v1707.1 {
                                                                                    let v1710 = constructor_bor(ctx, v2.0, v1457.0, v1457.1);
                                                                                    // Rule at src/opts/selects.isle line 129.
                                                                                    returns.extend(Some(v1710));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                            if v84.1 == v1707.1 {
                                                                                if v1457.1 == v1707.0 {
                                                                                    let v1710 = constructor_bor(ctx, v2.0, v1457.0, v1457.1);
                                                                                    // Rule at src/opts/selects.isle line 131.
                                                                                    returns.extend(Some(v1710));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                        if v84.1 == v1457.1 {
                                                                            let v1707 = C::unpack_value_array_2(ctx, v1706);
                                                                            if v84.1 == v1707.0 {
                                                                                if v1457.0 == v1707.1 {
                                                                                    let v1716 = constructor_bor(ctx, v2.0, v1457.1, v1457.0);
                                                                                    // Rule at src/opts/selects.isle line 133.
                                                                                    returns.extend(Some(v1716));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                            if v1457.0 == v1707.0 {
                                                                                if v84.1 == v1707.1 {
                                                                                    let v1716 = constructor_bor(ctx, v2.0, v1457.1, v1457.0);
                                                                                    // Rule at src/opts/selects.isle line 135.
                                                                                    returns.extend(Some(v1716));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                        &InstructionData::IntCompare {
                                                            opcode: ref v1474,
                                                            args: ref v1475,
                                                            cond: ref v1476,
                                                        } => {
                                                            if let &Opcode::Icmp = v1474 {
                                                                match v1476 {
                                                                    &IntCC::SignedGreaterThan => {
                                                                        let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                        let v1460 = C::value_type(ctx, v1457.0);
                                                                        if v1460 == I64 {
                                                                            let v1461 = C::value_type(ctx, v1457.1);
                                                                            if v1461 == I64 {
                                                                                if v2.0 == v1471.0 {
                                                                                    let v1477 = C::unpack_value_array_2(ctx, v1475);
                                                                                    if v1457.0 == v1477.0 {
                                                                                        if v1457.1 == v1477.1 {
                                                                                            let mut v94 = C::inst_data_value_etor_returns::default();
                                                                                            C::inst_data_value_etor(ctx, v84.1, &mut v94);
                                                                                            let mut v94 = v94.into_context_iter();
                                                                                            while let Some(v95) = v94.next(ctx) {
                                                                                                if let &InstructionData::IntCompare {
                                                                                                    opcode: ref v1462,
                                                                                                    args: ref v1463,
                                                                                                    cond: ref v1464,
                                                                                                } = &v95.1 {
                                                                                                    if let &Opcode::Icmp = v1462 {
                                                                                                        if let &IntCC::UnsignedGreaterThan = v1464 {
                                                                                                            let v1465 = C::unpack_value_array_2(ctx, v1463);
                                                                                                            let v1468 = C::value_type(ctx, v1465.0);
                                                                                                            if v1468 == I64 {
                                                                                                                let v1469 = C::value_type(ctx, v1465.1);
                                                                                                                if v1469 == I64 {
                                                                                                                    if v2.0 == v95.0 {
                                                                                                                        let v1480 = constructor_iconcat(ctx, I64, v1465.0, v1457.0);
                                                                                                                        let v1481 = constructor_iconcat(ctx, I64, v1465.1, v1457.1);
                                                                                                                        let v1485 = constructor_sgt(ctx, v2.0, v1480, v1481);
                                                                                                                        // Rule at src/opts/icmp.isle line 268.
                                                                                                                        returns.extend(Some(v1485));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedGreaterThanOrEqual => {
                                                                        let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                        let v1460 = C::value_type(ctx, v1457.0);
                                                                        if v1460 == I64 {
                                                                            let v1461 = C::value_type(ctx, v1457.1);
                                                                            if v1461 == I64 {
                                                                                if v2.0 == v1471.0 {
                                                                                    let v1477 = C::unpack_value_array_2(ctx, v1475);
                                                                                    if v1457.0 == v1477.0 {
                                                                                        if v1457.1 == v1477.1 {
                                                                                            let mut v94 = C::inst_data_value_etor_returns::default();
                                                                                            C::inst_data_value_etor(ctx, v84.1, &mut v94);
                                                                                            let mut v94 = v94.into_context_iter();
                                                                                            while let Some(v95) = v94.next(ctx) {
                                                                                                if let &InstructionData::IntCompare {
                                                                                                    opcode: ref v1462,
                                                                                                    args: ref v1463,
                                                                                                    cond: ref v1464,
                                                                                                } = &v95.1 {
                                                                                                    if let &Opcode::Icmp = v1462 {
                                                                                                        if let &IntCC::UnsignedGreaterThanOrEqual = v1464 {
                                                                                                            let v1465 = C::unpack_value_array_2(ctx, v1463);
                                                                                                            let v1468 = C::value_type(ctx, v1465.0);
                                                                                                            if v1468 == I64 {
                                                                                                                let v1469 = C::value_type(ctx, v1465.1);
                                                                                                                if v1469 == I64 {
                                                                                                                    if v2.0 == v95.0 {
                                                                                                                        let v1480 = constructor_iconcat(ctx, I64, v1465.0, v1457.0);
                                                                                                                        let v1481 = constructor_iconcat(ctx, I64, v1465.1, v1457.1);
                                                                                                                        let v1483 = constructor_sge(ctx, v2.0, v1480, v1481);
                                                                                                                        // Rule at src/opts/icmp.isle line 258.
                                                                                                                        returns.extend(Some(v1483));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedLessThan => {
                                                                        let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                        let v1460 = C::value_type(ctx, v1457.0);
                                                                        if v1460 == I64 {
                                                                            let v1461 = C::value_type(ctx, v1457.1);
                                                                            if v1461 == I64 {
                                                                                if v2.0 == v1471.0 {
                                                                                    let v1477 = C::unpack_value_array_2(ctx, v1475);
                                                                                    if v1457.0 == v1477.0 {
                                                                                        if v1457.1 == v1477.1 {
                                                                                            let mut v94 = C::inst_data_value_etor_returns::default();
                                                                                            C::inst_data_value_etor(ctx, v84.1, &mut v94);
                                                                                            let mut v94 = v94.into_context_iter();
                                                                                            while let Some(v95) = v94.next(ctx) {
                                                                                                if let &InstructionData::IntCompare {
                                                                                                    opcode: ref v1462,
                                                                                                    args: ref v1463,
                                                                                                    cond: ref v1464,
                                                                                                } = &v95.1 {
                                                                                                    if let &Opcode::Icmp = v1462 {
                                                                                                        if let &IntCC::UnsignedLessThan = v1464 {
                                                                                                            let v1465 = C::unpack_value_array_2(ctx, v1463);
                                                                                                            let v1468 = C::value_type(ctx, v1465.0);
                                                                                                            if v1468 == I64 {
                                                                                                                let v1469 = C::value_type(ctx, v1465.1);
                                                                                                                if v1469 == I64 {
                                                                                                                    if v2.0 == v95.0 {
                                                                                                                        let v1480 = constructor_iconcat(ctx, I64, v1465.0, v1457.0);
                                                                                                                        let v1481 = constructor_iconcat(ctx, I64, v1465.1, v1457.1);
                                                                                                                        let v1489 = constructor_slt(ctx, v2.0, v1480, v1481);
                                                                                                                        // Rule at src/opts/icmp.isle line 288.
                                                                                                                        returns.extend(Some(v1489));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedLessThanOrEqual => {
                                                                        let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                        let v1460 = C::value_type(ctx, v1457.0);
                                                                        if v1460 == I64 {
                                                                            let v1461 = C::value_type(ctx, v1457.1);
                                                                            if v1461 == I64 {
                                                                                if v2.0 == v1471.0 {
                                                                                    let v1477 = C::unpack_value_array_2(ctx, v1475);
                                                                                    if v1457.0 == v1477.0 {
                                                                                        if v1457.1 == v1477.1 {
                                                                                            let mut v94 = C::inst_data_value_etor_returns::default();
                                                                                            C::inst_data_value_etor(ctx, v84.1, &mut v94);
                                                                                            let mut v94 = v94.into_context_iter();
                                                                                            while let Some(v95) = v94.next(ctx) {
                                                                                                if let &InstructionData::IntCompare {
                                                                                                    opcode: ref v1462,
                                                                                                    args: ref v1463,
                                                                                                    cond: ref v1464,
                                                                                                } = &v95.1 {
                                                                                                    if let &Opcode::Icmp = v1462 {
                                                                                                        if let &IntCC::UnsignedLessThanOrEqual = v1464 {
                                                                                                            let v1465 = C::unpack_value_array_2(ctx, v1463);
                                                                                                            let v1468 = C::value_type(ctx, v1465.0);
                                                                                                            if v1468 == I64 {
                                                                                                                let v1469 = C::value_type(ctx, v1465.1);
                                                                                                                if v1469 == I64 {
                                                                                                                    if v2.0 == v95.0 {
                                                                                                                        let v1480 = constructor_iconcat(ctx, I64, v1465.0, v1457.0);
                                                                                                                        let v1481 = constructor_iconcat(ctx, I64, v1465.1, v1457.1);
                                                                                                                        let v1487 = constructor_sle(ctx, v2.0, v1480, v1481);
                                                                                                                        // Rule at src/opts/icmp.isle line 278.
                                                                                                                        returns.extend(Some(v1487));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedGreaterThan => {
                                                                        let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                        let v1460 = C::value_type(ctx, v1457.0);
                                                                        if v1460 == I64 {
                                                                            let v1461 = C::value_type(ctx, v1457.1);
                                                                            if v1461 == I64 {
                                                                                if v2.0 == v1471.0 {
                                                                                    let v1477 = C::unpack_value_array_2(ctx, v1475);
                                                                                    if v1457.0 == v1477.0 {
                                                                                        if v1457.1 == v1477.1 {
                                                                                            let mut v94 = C::inst_data_value_etor_returns::default();
                                                                                            C::inst_data_value_etor(ctx, v84.1, &mut v94);
                                                                                            let mut v94 = v94.into_context_iter();
                                                                                            while let Some(v95) = v94.next(ctx) {
                                                                                                if let &InstructionData::IntCompare {
                                                                                                    opcode: ref v1462,
                                                                                                    args: ref v1463,
                                                                                                    cond: ref v1464,
                                                                                                } = &v95.1 {
                                                                                                    if let &Opcode::Icmp = v1462 {
                                                                                                        if let &IntCC::UnsignedGreaterThan = v1464 {
                                                                                                            let v1465 = C::unpack_value_array_2(ctx, v1463);
                                                                                                            let v1468 = C::value_type(ctx, v1465.0);
                                                                                                            if v1468 == I64 {
                                                                                                                let v1469 = C::value_type(ctx, v1465.1);
                                                                                                                if v1469 == I64 {
                                                                                                                    if v2.0 == v95.0 {
                                                                                                                        let v1480 = constructor_iconcat(ctx, I64, v1465.0, v1457.0);
                                                                                                                        let v1481 = constructor_iconcat(ctx, I64, v1465.1, v1457.1);
                                                                                                                        let v1484 = constructor_ugt(ctx, v2.0, v1480, v1481);
                                                                                                                        // Rule at src/opts/icmp.isle line 263.
                                                                                                                        returns.extend(Some(v1484));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedGreaterThanOrEqual => {
                                                                        let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                        let v1460 = C::value_type(ctx, v1457.0);
                                                                        if v1460 == I64 {
                                                                            let v1461 = C::value_type(ctx, v1457.1);
                                                                            if v1461 == I64 {
                                                                                if v2.0 == v1471.0 {
                                                                                    let v1477 = C::unpack_value_array_2(ctx, v1475);
                                                                                    if v1457.0 == v1477.0 {
                                                                                        if v1457.1 == v1477.1 {
                                                                                            let mut v94 = C::inst_data_value_etor_returns::default();
                                                                                            C::inst_data_value_etor(ctx, v84.1, &mut v94);
                                                                                            let mut v94 = v94.into_context_iter();
                                                                                            while let Some(v95) = v94.next(ctx) {
                                                                                                if let &InstructionData::IntCompare {
                                                                                                    opcode: ref v1462,
                                                                                                    args: ref v1463,
                                                                                                    cond: ref v1464,
                                                                                                } = &v95.1 {
                                                                                                    if let &Opcode::Icmp = v1462 {
                                                                                                        if let &IntCC::UnsignedGreaterThanOrEqual = v1464 {
                                                                                                            let v1465 = C::unpack_value_array_2(ctx, v1463);
                                                                                                            let v1468 = C::value_type(ctx, v1465.0);
                                                                                                            if v1468 == I64 {
                                                                                                                let v1469 = C::value_type(ctx, v1465.1);
                                                                                                                if v1469 == I64 {
                                                                                                                    if v2.0 == v95.0 {
                                                                                                                        let v1480 = constructor_iconcat(ctx, I64, v1465.0, v1457.0);
                                                                                                                        let v1481 = constructor_iconcat(ctx, I64, v1465.1, v1457.1);
                                                                                                                        let v1482 = constructor_uge(ctx, v2.0, v1480, v1481);
                                                                                                                        // Rule at src/opts/icmp.isle line 253.
                                                                                                                        returns.extend(Some(v1482));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                        let v1460 = C::value_type(ctx, v1457.0);
                                                                        if v1460 == I64 {
                                                                            let v1461 = C::value_type(ctx, v1457.1);
                                                                            if v1461 == I64 {
                                                                                if v2.0 == v1471.0 {
                                                                                    let v1477 = C::unpack_value_array_2(ctx, v1475);
                                                                                    if v1457.0 == v1477.0 {
                                                                                        if v1457.1 == v1477.1 {
                                                                                            let mut v94 = C::inst_data_value_etor_returns::default();
                                                                                            C::inst_data_value_etor(ctx, v84.1, &mut v94);
                                                                                            let mut v94 = v94.into_context_iter();
                                                                                            while let Some(v95) = v94.next(ctx) {
                                                                                                if let &InstructionData::IntCompare {
                                                                                                    opcode: ref v1462,
                                                                                                    args: ref v1463,
                                                                                                    cond: ref v1464,
                                                                                                } = &v95.1 {
                                                                                                    if let &Opcode::Icmp = v1462 {
                                                                                                        if let &IntCC::UnsignedLessThan = v1464 {
                                                                                                            let v1465 = C::unpack_value_array_2(ctx, v1463);
                                                                                                            let v1468 = C::value_type(ctx, v1465.0);
                                                                                                            if v1468 == I64 {
                                                                                                                let v1469 = C::value_type(ctx, v1465.1);
                                                                                                                if v1469 == I64 {
                                                                                                                    if v2.0 == v95.0 {
                                                                                                                        let v1480 = constructor_iconcat(ctx, I64, v1465.0, v1457.0);
                                                                                                                        let v1481 = constructor_iconcat(ctx, I64, v1465.1, v1457.1);
                                                                                                                        let v1488 = constructor_ult(ctx, v2.0, v1480, v1481);
                                                                                                                        // Rule at src/opts/icmp.isle line 283.
                                                                                                                        returns.extend(Some(v1488));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThanOrEqual => {
                                                                        let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                        let v1460 = C::value_type(ctx, v1457.0);
                                                                        if v1460 == I64 {
                                                                            let v1461 = C::value_type(ctx, v1457.1);
                                                                            if v1461 == I64 {
                                                                                if v2.0 == v1471.0 {
                                                                                    let v1477 = C::unpack_value_array_2(ctx, v1475);
                                                                                    if v1457.0 == v1477.0 {
                                                                                        if v1457.1 == v1477.1 {
                                                                                            let mut v94 = C::inst_data_value_etor_returns::default();
                                                                                            C::inst_data_value_etor(ctx, v84.1, &mut v94);
                                                                                            let mut v94 = v94.into_context_iter();
                                                                                            while let Some(v95) = v94.next(ctx) {
                                                                                                if let &InstructionData::IntCompare {
                                                                                                    opcode: ref v1462,
                                                                                                    args: ref v1463,
                                                                                                    cond: ref v1464,
                                                                                                } = &v95.1 {
                                                                                                    if let &Opcode::Icmp = v1462 {
                                                                                                        if let &IntCC::UnsignedLessThanOrEqual = v1464 {
                                                                                                            let v1465 = C::unpack_value_array_2(ctx, v1463);
                                                                                                            let v1468 = C::value_type(ctx, v1465.0);
                                                                                                            if v1468 == I64 {
                                                                                                                let v1469 = C::value_type(ctx, v1465.1);
                                                                                                                if v1469 == I64 {
                                                                                                                    if v2.0 == v95.0 {
                                                                                                                        let v1480 = constructor_iconcat(ctx, I64, v1465.0, v1457.0);
                                                                                                                        let v1481 = constructor_iconcat(ctx, I64, v1465.1, v1457.1);
                                                                                                                        let v1486 = constructor_ule(ctx, v2.0, v1480, v1481);
                                                                                                                        // Rule at src/opts/icmp.isle line 273.
                                                                                                                        returns.extend(Some(v1486));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::Ternary {
                                                            opcode: ref v1659,
                                                            args: ref v1660,
                                                        } => {
                                                            if let &Opcode::Select = v1659 {
                                                                if v2.0 == v1471.0 {
                                                                    let mut v1591 = C::inst_data_value_tupled_etor_returns::default();
                                                                    C::inst_data_value_tupled_etor(ctx, v84.1, &mut v1591);
                                                                    let mut v1591 = v1591.into_context_iter();
                                                                    while let Some(v1592) = v1591.next(ctx) {
                                                                        let v1593 = C::iconst_sextend_etor(ctx, v1592);
                                                                        if let Some(v1594) = v1593 {
                                                                            if v1594.1 == 0_i64 {
                                                                                if v2.0 == v1594.0 {
                                                                                    let v1661 = C::unpack_value_array_3(ctx, v1660);
                                                                                    let mut v1893 = C::inst_data_value_etor_returns::default();
                                                                                    C::inst_data_value_etor(ctx, v1661.0, &mut v1893);
                                                                                    let mut v1893 = v1893.into_context_iter();
                                                                                    while let Some(v1894) = v1893.next(ctx) {
                                                                                        if let &InstructionData::IntCompare {
                                                                                            opcode: ref v1897,
                                                                                            args: ref v1898,
                                                                                            cond: ref v1899,
                                                                                        } = &v1894.1 {
                                                                                            if let &Opcode::Icmp = v1897 {
                                                                                                match v1899 {
                                                                                                    &IntCC::SignedGreaterThan => {
                                                                                                        if v89.0 == v1894.0 {
                                                                                                            let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                                                            let v1900 = C::unpack_value_array_2(ctx, v1898);
                                                                                                            if v1457.0 == v1900.0 {
                                                                                                                if v1457.1 == v1900.1 {
                                                                                                                    let mut v1903 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1661.1, &mut v1903);
                                                                                                                    let mut v1903 = v1903.into_context_iter();
                                                                                                                    while let Some(v1904) = v1903.next(ctx) {
                                                                                                                        let v1905 = C::iconst_sextend_etor(ctx, v1904);
                                                                                                                        if let Some(v1906) = v1905 {
                                                                                                                            if v1906.1 == 1_i64 {
                                                                                                                                if v2.0 == v1906.0 {
                                                                                                                                    let mut v1909 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1661.2, &mut v1909);
                                                                                                                                    let mut v1909 = v1909.into_context_iter();
                                                                                                                                    while let Some(v1910) = v1909.next(ctx) {
                                                                                                                                        let v1911 = C::iconst_sextend_etor(ctx, v1910);
                                                                                                                                        if let Some(v1912) = v1911 {
                                                                                                                                            if v1912.1 == -1_i64 {
                                                                                                                                                if v2.0 == v1912.0 {
                                                                                                                                                    let v1925 = constructor_spaceship_s(ctx, v89.0, v1457.0, v1457.1);
                                                                                                                                                    let v1926 = constructor_sextend_maybe(ctx, v2.0, v1925);
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 103.
                                                                                                                                                    returns.extend(Some(v1926));
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    &IntCC::SignedGreaterThanOrEqual => {
                                                                                                        if v89.0 == v1894.0 {
                                                                                                            let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                                                            let v1900 = C::unpack_value_array_2(ctx, v1898);
                                                                                                            if v1457.0 == v1900.0 {
                                                                                                                if v1457.1 == v1900.1 {
                                                                                                                    let mut v1903 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1661.1, &mut v1903);
                                                                                                                    let mut v1903 = v1903.into_context_iter();
                                                                                                                    while let Some(v1904) = v1903.next(ctx) {
                                                                                                                        let v1905 = C::iconst_sextend_etor(ctx, v1904);
                                                                                                                        if let Some(v1906) = v1905 {
                                                                                                                            if v1906.1 == 1_i64 {
                                                                                                                                if v2.0 == v1906.0 {
                                                                                                                                    let mut v1909 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1661.2, &mut v1909);
                                                                                                                                    let mut v1909 = v1909.into_context_iter();
                                                                                                                                    while let Some(v1910) = v1909.next(ctx) {
                                                                                                                                        let v1911 = C::iconst_sextend_etor(ctx, v1910);
                                                                                                                                        if let Some(v1912) = v1911 {
                                                                                                                                            if v1912.1 == -1_i64 {
                                                                                                                                                if v2.0 == v1912.0 {
                                                                                                                                                    let v1925 = constructor_spaceship_s(ctx, v89.0, v1457.0, v1457.1);
                                                                                                                                                    let v1926 = constructor_sextend_maybe(ctx, v2.0, v1925);
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 110.
                                                                                                                                                    returns.extend(Some(v1926));
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    &IntCC::SignedLessThan => {
                                                                                                        if v89.0 == v1894.0 {
                                                                                                            let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                                                            let v1900 = C::unpack_value_array_2(ctx, v1898);
                                                                                                            if v1457.0 == v1900.0 {
                                                                                                                if v1457.1 == v1900.1 {
                                                                                                                    let mut v1903 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1661.1, &mut v1903);
                                                                                                                    let mut v1903 = v1903.into_context_iter();
                                                                                                                    while let Some(v1904) = v1903.next(ctx) {
                                                                                                                        let v1905 = C::iconst_sextend_etor(ctx, v1904);
                                                                                                                        if let Some(v1906) = v1905 {
                                                                                                                            if v1906.1 == -1_i64 {
                                                                                                                                if v2.0 == v1906.0 {
                                                                                                                                    let mut v1909 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1661.2, &mut v1909);
                                                                                                                                    let mut v1909 = v1909.into_context_iter();
                                                                                                                                    while let Some(v1910) = v1909.next(ctx) {
                                                                                                                                        let v1911 = C::iconst_sextend_etor(ctx, v1910);
                                                                                                                                        if let Some(v1912) = v1911 {
                                                                                                                                            if v1912.1 == 1_i64 {
                                                                                                                                                if v2.0 == v1912.0 {
                                                                                                                                                    let v1925 = constructor_spaceship_s(ctx, v89.0, v1457.0, v1457.1);
                                                                                                                                                    let v1926 = constructor_sextend_maybe(ctx, v2.0, v1925);
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 89.
                                                                                                                                                    returns.extend(Some(v1926));
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    &IntCC::SignedLessThanOrEqual => {
                                                                                                        if v89.0 == v1894.0 {
                                                                                                            let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                                                            let v1900 = C::unpack_value_array_2(ctx, v1898);
                                                                                                            if v1457.0 == v1900.0 {
                                                                                                                if v1457.1 == v1900.1 {
                                                                                                                    let mut v1903 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1661.1, &mut v1903);
                                                                                                                    let mut v1903 = v1903.into_context_iter();
                                                                                                                    while let Some(v1904) = v1903.next(ctx) {
                                                                                                                        let v1905 = C::iconst_sextend_etor(ctx, v1904);
                                                                                                                        if let Some(v1906) = v1905 {
                                                                                                                            if v1906.1 == -1_i64 {
                                                                                                                                if v2.0 == v1906.0 {
                                                                                                                                    let mut v1909 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1661.2, &mut v1909);
                                                                                                                                    let mut v1909 = v1909.into_context_iter();
                                                                                                                                    while let Some(v1910) = v1909.next(ctx) {
                                                                                                                                        let v1911 = C::iconst_sextend_etor(ctx, v1910);
                                                                                                                                        if let Some(v1912) = v1911 {
                                                                                                                                            if v1912.1 == 1_i64 {
                                                                                                                                                if v2.0 == v1912.0 {
                                                                                                                                                    let v1925 = constructor_spaceship_s(ctx, v89.0, v1457.0, v1457.1);
                                                                                                                                                    let v1926 = constructor_sextend_maybe(ctx, v2.0, v1925);
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 96.
                                                                                                                                                    returns.extend(Some(v1926));
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    &IntCC::UnsignedGreaterThan => {
                                                                                                        if v89.0 == v1894.0 {
                                                                                                            let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                                                            let v1900 = C::unpack_value_array_2(ctx, v1898);
                                                                                                            if v1457.0 == v1900.0 {
                                                                                                                if v1457.1 == v1900.1 {
                                                                                                                    let mut v1903 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1661.1, &mut v1903);
                                                                                                                    let mut v1903 = v1903.into_context_iter();
                                                                                                                    while let Some(v1904) = v1903.next(ctx) {
                                                                                                                        let v1905 = C::iconst_sextend_etor(ctx, v1904);
                                                                                                                        if let Some(v1906) = v1905 {
                                                                                                                            if v1906.1 == 1_i64 {
                                                                                                                                if v2.0 == v1906.0 {
                                                                                                                                    let mut v1909 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1661.2, &mut v1909);
                                                                                                                                    let mut v1909 = v1909.into_context_iter();
                                                                                                                                    while let Some(v1910) = v1909.next(ctx) {
                                                                                                                                        let v1911 = C::iconst_sextend_etor(ctx, v1910);
                                                                                                                                        if let Some(v1912) = v1911 {
                                                                                                                                            if v1912.1 == -1_i64 {
                                                                                                                                                if v2.0 == v1912.0 {
                                                                                                                                                    let v1891 = constructor_spaceship_u(ctx, v89.0, v1457.0, v1457.1);
                                                                                                                                                    let v1892 = constructor_sextend_maybe(ctx, v2.0, v1891);
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 38.
                                                                                                                                                    returns.extend(Some(v1892));
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    &IntCC::UnsignedGreaterThanOrEqual => {
                                                                                                        if v89.0 == v1894.0 {
                                                                                                            let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                                                            let v1900 = C::unpack_value_array_2(ctx, v1898);
                                                                                                            if v1457.0 == v1900.0 {
                                                                                                                if v1457.1 == v1900.1 {
                                                                                                                    let mut v1903 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1661.1, &mut v1903);
                                                                                                                    let mut v1903 = v1903.into_context_iter();
                                                                                                                    while let Some(v1904) = v1903.next(ctx) {
                                                                                                                        let v1905 = C::iconst_sextend_etor(ctx, v1904);
                                                                                                                        if let Some(v1906) = v1905 {
                                                                                                                            if v1906.1 == 1_i64 {
                                                                                                                                if v2.0 == v1906.0 {
                                                                                                                                    let mut v1909 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1661.2, &mut v1909);
                                                                                                                                    let mut v1909 = v1909.into_context_iter();
                                                                                                                                    while let Some(v1910) = v1909.next(ctx) {
                                                                                                                                        let v1911 = C::iconst_sextend_etor(ctx, v1910);
                                                                                                                                        if let Some(v1912) = v1911 {
                                                                                                                                            if v1912.1 == -1_i64 {
                                                                                                                                                if v2.0 == v1912.0 {
                                                                                                                                                    let v1891 = constructor_spaceship_u(ctx, v89.0, v1457.0, v1457.1);
                                                                                                                                                    let v1892 = constructor_sextend_maybe(ctx, v2.0, v1891);
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 45.
                                                                                                                                                    returns.extend(Some(v1892));
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    &IntCC::UnsignedLessThan => {
                                                                                                        if v89.0 == v1894.0 {
                                                                                                            let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                                                            let v1900 = C::unpack_value_array_2(ctx, v1898);
                                                                                                            if v1457.0 == v1900.0 {
                                                                                                                if v1457.1 == v1900.1 {
                                                                                                                    let mut v1903 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1661.1, &mut v1903);
                                                                                                                    let mut v1903 = v1903.into_context_iter();
                                                                                                                    while let Some(v1904) = v1903.next(ctx) {
                                                                                                                        let v1905 = C::iconst_sextend_etor(ctx, v1904);
                                                                                                                        if let Some(v1906) = v1905 {
                                                                                                                            if v1906.1 == -1_i64 {
                                                                                                                                if v2.0 == v1906.0 {
                                                                                                                                    let mut v1909 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1661.2, &mut v1909);
                                                                                                                                    let mut v1909 = v1909.into_context_iter();
                                                                                                                                    while let Some(v1910) = v1909.next(ctx) {
                                                                                                                                        let v1911 = C::iconst_sextend_etor(ctx, v1910);
                                                                                                                                        if let Some(v1912) = v1911 {
                                                                                                                                            if v1912.1 == 1_i64 {
                                                                                                                                                if v2.0 == v1912.0 {
                                                                                                                                                    let v1891 = constructor_spaceship_u(ctx, v89.0, v1457.0, v1457.1);
                                                                                                                                                    let v1892 = constructor_sextend_maybe(ctx, v2.0, v1891);
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 24.
                                                                                                                                                    returns.extend(Some(v1892));
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    &IntCC::UnsignedLessThanOrEqual => {
                                                                                                        if v89.0 == v1894.0 {
                                                                                                            let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                                                            let v1900 = C::unpack_value_array_2(ctx, v1898);
                                                                                                            if v1457.0 == v1900.0 {
                                                                                                                if v1457.1 == v1900.1 {
                                                                                                                    let mut v1903 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1661.1, &mut v1903);
                                                                                                                    let mut v1903 = v1903.into_context_iter();
                                                                                                                    while let Some(v1904) = v1903.next(ctx) {
                                                                                                                        let v1905 = C::iconst_sextend_etor(ctx, v1904);
                                                                                                                        if let Some(v1906) = v1905 {
                                                                                                                            if v1906.1 == -1_i64 {
                                                                                                                                if v2.0 == v1906.0 {
                                                                                                                                    let mut v1909 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1661.2, &mut v1909);
                                                                                                                                    let mut v1909 = v1909.into_context_iter();
                                                                                                                                    while let Some(v1910) = v1909.next(ctx) {
                                                                                                                                        let v1911 = C::iconst_sextend_etor(ctx, v1910);
                                                                                                                                        if let Some(v1912) = v1911 {
                                                                                                                                            if v1912.1 == 1_i64 {
                                                                                                                                                if v2.0 == v1912.0 {
                                                                                                                                                    let v1891 = constructor_spaceship_u(ctx, v89.0, v1457.0, v1457.1);
                                                                                                                                                    let v1892 = constructor_sextend_maybe(ctx, v2.0, v1891);
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 31.
                                                                                                                                                    returns.extend(Some(v1892));
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    _ => {}
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                if v84.1 == v1457.0 {
                                                    if v84.2 == v1457.1 {
                                                        let v1674 = C::subsume(ctx, v1457.1);
                                                        // Rule at src/opts/selects.isle line 116.
                                                        returns.extend(Some(v1674));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v84.2 == v1457.0 {
                                                    if v84.1 == v1457.1 {
                                                        let v1675 = C::subsume(ctx, v1457.0);
                                                        // Rule at src/opts/selects.isle line 118.
                                                        returns.extend(Some(v1675));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::NotEqual => {
                                                let mut v94 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v84.1, &mut v94);
                                                let mut v94 = v94.into_context_iter();
                                                while let Some(v95) = v94.next(ctx) {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v1711,
                                                        args: ref v1712,
                                                    } = &v95.1 {
                                                        match v1711 {
                                                            &Opcode::Isub => {
                                                                if v2.0 == v95.0 {
                                                                    let mut v1470 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v84.2, &mut v1470);
                                                                    let mut v1470 = v1470.into_context_iter();
                                                                    while let Some(v1471) = v1470.next(ctx) {
                                                                        if let &InstructionData::Binary {
                                                                            opcode: ref v1705,
                                                                            args: ref v1706,
                                                                        } = &v1471.1 {
                                                                            if let &Opcode::Isub = v1705 {
                                                                                if v2.0 == v1471.0 {
                                                                                    let v1707 = C::unpack_value_array_2(ctx, v1706);
                                                                                    let v1713 = C::unpack_value_array_2(ctx, v1712);
                                                                                    if v1707.0 == v1713.0 {
                                                                                        let mut v1733 = C::inst_data_value_etor_returns::default();
                                                                                        C::inst_data_value_etor(ctx, v1707.1, &mut v1733);
                                                                                        let mut v1733 = v1733.into_context_iter();
                                                                                        while let Some(v1734) = v1733.next(ctx) {
                                                                                            if let &InstructionData::UnaryImm {
                                                                                                opcode: ref v1737,
                                                                                                imm: v1738,
                                                                                            } = &v1734.1 {
                                                                                                if let &Opcode::Iconst = v1737 {
                                                                                                    if v2.0 == v1734.0 {
                                                                                                        let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                                                        if v1457.0 == v1713.1 {
                                                                                                            let mut v1627 = C::inst_data_value_etor_returns::default();
                                                                                                            C::inst_data_value_etor(ctx, v1457.1, &mut v1627);
                                                                                                            let mut v1627 = v1627.into_context_iter();
                                                                                                            while let Some(v1628) = v1627.next(ctx) {
                                                                                                                if let &InstructionData::UnaryImm {
                                                                                                                    opcode: ref v1631,
                                                                                                                    imm: v1632,
                                                                                                                } = &v1628.1 {
                                                                                                                    if let &Opcode::Iconst = v1631 {
                                                                                                                        if v2.0 == v1628.0 {
                                                                                                                            let v1633 = C::u64_from_imm64(ctx, v1632);
                                                                                                                            let v1739 = C::u64_from_imm64(ctx, v1738);
                                                                                                                            if v1633 == v1739 {
                                                                                                                                let v1732 = constructor_isub(ctx, v2.0, v1713.0, v1457.0);
                                                                                                                                // Rule at src/opts/selects.isle line 186.
                                                                                                                                returns.extend(Some(v1732));
                                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                        if v1457.1 == v1713.1 {
                                                                                                            let mut v1740 = C::inst_data_value_etor_returns::default();
                                                                                                            C::inst_data_value_etor(ctx, v1457.0, &mut v1740);
                                                                                                            let mut v1740 = v1740.into_context_iter();
                                                                                                            while let Some(v1741) = v1740.next(ctx) {
                                                                                                                if let &InstructionData::UnaryImm {
                                                                                                                    opcode: ref v1744,
                                                                                                                    imm: v1745,
                                                                                                                } = &v1741.1 {
                                                                                                                    if let &Opcode::Iconst = v1744 {
                                                                                                                        if v2.0 == v1741.0 {
                                                                                                                            let v1739 = C::u64_from_imm64(ctx, v1738);
                                                                                                                            let v1746 = C::u64_from_imm64(ctx, v1745);
                                                                                                                            if v1739 == v1746 {
                                                                                                                                let v1747 = constructor_isub(ctx, v2.0, v1713.0, v1457.1);
                                                                                                                                // Rule at src/opts/selects.isle line 188.
                                                                                                                                returns.extend(Some(v1747));
                                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Band => {
                                                                if v2.0 == v95.0 {
                                                                    let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                    if v84.2 == v1457.0 {
                                                                        let v1713 = C::unpack_value_array_2(ctx, v1712);
                                                                        if v84.2 == v1713.0 {
                                                                            if v1457.1 == v1713.1 {
                                                                                let v1718 = constructor_band(ctx, v2.0, v1457.1, v1457.0);
                                                                                // Rule at src/opts/selects.isle line 146.
                                                                                returns.extend(Some(v1718));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                        if v84.2 == v1713.1 {
                                                                            if v1457.1 == v1713.0 {
                                                                                let v1718 = constructor_band(ctx, v2.0, v1457.1, v1457.0);
                                                                                // Rule at src/opts/selects.isle line 144.
                                                                                returns.extend(Some(v1718));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                    if v84.2 == v1457.1 {
                                                                        let v1713 = C::unpack_value_array_2(ctx, v1712);
                                                                        if v84.2 == v1713.0 {
                                                                            if v1457.0 == v1713.1 {
                                                                                let v1717 = constructor_band(ctx, v2.0, v1457.0, v1457.1);
                                                                                // Rule at src/opts/selects.isle line 142.
                                                                                returns.extend(Some(v1717));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                        if v1457.0 == v1713.0 {
                                                                            if v84.2 == v1713.1 {
                                                                                let v1717 = constructor_band(ctx, v2.0, v1457.0, v1457.1);
                                                                                // Rule at src/opts/selects.isle line 140.
                                                                                returns.extend(Some(v1717));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Bor => {
                                                                if v2.0 == v95.0 {
                                                                    let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                    if v84.2 == v1457.0 {
                                                                        let v1713 = C::unpack_value_array_2(ctx, v1712);
                                                                        if v84.2 == v1713.0 {
                                                                            if v1457.1 == v1713.1 {
                                                                                let v1710 = constructor_bor(ctx, v2.0, v1457.0, v1457.1);
                                                                                // Rule at src/opts/selects.isle line 130.
                                                                                returns.extend(Some(v1710));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                        if v84.2 == v1713.1 {
                                                                            if v1457.1 == v1713.0 {
                                                                                let v1710 = constructor_bor(ctx, v2.0, v1457.0, v1457.1);
                                                                                // Rule at src/opts/selects.isle line 132.
                                                                                returns.extend(Some(v1710));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                    if v84.2 == v1457.1 {
                                                                        let v1713 = C::unpack_value_array_2(ctx, v1712);
                                                                        if v84.2 == v1713.0 {
                                                                            if v1457.0 == v1713.1 {
                                                                                let v1716 = constructor_bor(ctx, v2.0, v1457.1, v1457.0);
                                                                                // Rule at src/opts/selects.isle line 134.
                                                                                returns.extend(Some(v1716));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                        if v1457.0 == v1713.0 {
                                                                            if v84.2 == v1713.1 {
                                                                                let v1716 = constructor_bor(ctx, v2.0, v1457.1, v1457.0);
                                                                                // Rule at src/opts/selects.isle line 136.
                                                                                returns.extend(Some(v1716));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                    }
                                                }
                                                let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                if v84.1 == v1457.0 {
                                                    if v84.2 == v1457.1 {
                                                        let v1675 = C::subsume(ctx, v1457.0);
                                                        // Rule at src/opts/selects.isle line 119.
                                                        returns.extend(Some(v1675));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v84.1 == v1457.1 {
                                                    if v84.2 == v1457.0 {
                                                        let v1674 = C::subsume(ctx, v1457.1);
                                                        // Rule at src/opts/selects.isle line 117.
                                                        returns.extend(Some(v1674));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::SignedGreaterThan => {
                                                let mut v1470 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v84.2, &mut v1470);
                                                let mut v1470 = v1470.into_context_iter();
                                                while let Some(v1471) = v1470.next(ctx) {
                                                    match &v1471.1 {
                                                        &InstructionData::IntCompare {
                                                            opcode: ref v1474,
                                                            args: ref v1475,
                                                            cond: ref v1476,
                                                        } => {
                                                            if let &Opcode::Icmp = v1474 {
                                                                match v1476 {
                                                                    &IntCC::SignedGreaterThan => {
                                                                        if v2.0 == v1471.0 {
                                                                            let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                            let v1477 = C::unpack_value_array_2(ctx, v1475);
                                                                            if v1457.0 == v1477.1 {
                                                                                if v1457.1 == v1477.0 {
                                                                                    let mut v94 = C::inst_data_value_etor_returns::default();
                                                                                    C::inst_data_value_etor(ctx, v84.1, &mut v94);
                                                                                    let mut v94 = v94.into_context_iter();
                                                                                    while let Some(v95) = v94.next(ctx) {
                                                                                        if let &InstructionData::UnaryImm {
                                                                                            opcode: ref v1579,
                                                                                            imm: v1580,
                                                                                        } = &v95.1 {
                                                                                            if let &Opcode::Iconst = v1579 {
                                                                                                let v1581 = C::u64_from_imm64(ctx, v1580);
                                                                                                if v1581 == 0x1_u64 {
                                                                                                    if v2.0 == v95.0 {
                                                                                                        let v1722 = constructor_ne(ctx, v2.0, v1457.1, v1457.0);
                                                                                                        // Rule at src/opts/selects.isle line 164.
                                                                                                        returns.extend(Some(v1722));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedLessThan => {
                                                                        if v2.0 == v1471.0 {
                                                                            let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                            let v1477 = C::unpack_value_array_2(ctx, v1475);
                                                                            if v1457.0 == v1477.0 {
                                                                                if v1457.1 == v1477.1 {
                                                                                    let mut v94 = C::inst_data_value_etor_returns::default();
                                                                                    C::inst_data_value_etor(ctx, v84.1, &mut v94);
                                                                                    let mut v94 = v94.into_context_iter();
                                                                                    while let Some(v95) = v94.next(ctx) {
                                                                                        if let &InstructionData::UnaryImm {
                                                                                            opcode: ref v1579,
                                                                                            imm: v1580,
                                                                                        } = &v95.1 {
                                                                                            if let &Opcode::Iconst = v1579 {
                                                                                                let v1581 = C::u64_from_imm64(ctx, v1580);
                                                                                                if v1581 == 0x1_u64 {
                                                                                                    if v2.0 == v95.0 {
                                                                                                        let v1722 = constructor_ne(ctx, v2.0, v1457.1, v1457.0);
                                                                                                        // Rule at src/opts/selects.isle line 168.
                                                                                                        returns.extend(Some(v1722));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v1621,
                                                            arg: v1622,
                                                        } => {
                                                            match v1621 {
                                                                &Opcode::Ineg => {
                                                                    if v89.0 == v1471.0 {
                                                                        let mut v1591 = C::inst_data_value_tupled_etor_returns::default();
                                                                        C::inst_data_value_tupled_etor(ctx, v84.1, &mut v1591);
                                                                        let mut v1591 = v1591.into_context_iter();
                                                                        while let Some(v1592) = v1591.next(ctx) {
                                                                            let v1593 = C::iconst_sextend_etor(ctx, v1592);
                                                                            if let Some(v1594) = v1593 {
                                                                                if v1594.1 == 1_i64 {
                                                                                    if v2.0 == v1594.0 {
                                                                                        let mut v1915 = C::inst_data_value_etor_returns::default();
                                                                                        C::inst_data_value_etor(ctx, v1622, &mut v1915);
                                                                                        let mut v1915 = v1915.into_context_iter();
                                                                                        while let Some(v1916) = v1915.next(ctx) {
                                                                                            if let &InstructionData::IntCompare {
                                                                                                opcode: ref v1919,
                                                                                                args: ref v1920,
                                                                                                cond: ref v1921,
                                                                                            } = &v1916.1 {
                                                                                                if let &Opcode::Icmp = v1919 {
                                                                                                    match v1921 {
                                                                                                        &IntCC::NotEqual => {
                                                                                                            if v89.0 == v1916.0 {
                                                                                                                let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                                                                let v1922 = C::unpack_value_array_2(ctx, v1920);
                                                                                                                if v1457.0 == v1922.0 {
                                                                                                                    if v1457.1 == v1922.1 {
                                                                                                                        let v1925 = constructor_spaceship_s(ctx, v89.0, v1457.0, v1457.1);
                                                                                                                        let v1926 = constructor_sextend_maybe(ctx, v2.0, v1925);
                                                                                                                        // Rule at src/opts/spaceship.isle line 129.
                                                                                                                        returns.extend(Some(v1926));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                        &IntCC::SignedLessThan => {
                                                                                                            if v89.0 == v1916.0 {
                                                                                                                let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                                                                let v1922 = C::unpack_value_array_2(ctx, v1920);
                                                                                                                if v1457.0 == v1922.0 {
                                                                                                                    if v1457.1 == v1922.1 {
                                                                                                                        let v1925 = constructor_spaceship_s(ctx, v89.0, v1457.0, v1457.1);
                                                                                                                        let v1926 = constructor_sextend_maybe(ctx, v2.0, v1925);
                                                                                                                        // Rule at src/opts/spaceship.isle line 119.
                                                                                                                        returns.extend(Some(v1926));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                        _ => {}
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    if v2.0 == v1471.0 {
                                                                        let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                        if v84.1 == v1457.0 {
                                                                            if v84.1 == v1622 {
                                                                                let mut v1627 = C::inst_data_value_etor_returns::default();
                                                                                C::inst_data_value_etor(ctx, v1457.1, &mut v1627);
                                                                                let mut v1627 = v1627.into_context_iter();
                                                                                while let Some(v1628) = v1627.next(ctx) {
                                                                                    if let &InstructionData::UnaryImm {
                                                                                        opcode: ref v1631,
                                                                                        imm: v1632,
                                                                                    } = &v1628.1 {
                                                                                        if let &Opcode::Iconst = v1631 {
                                                                                            let v1633 = C::u64_from_imm64(ctx, v1632);
                                                                                            if v1633 == 0x0_u64 {
                                                                                                if v2.0 == v1628.0 {
                                                                                                    let v1634 = constructor_iabs(ctx, v2.0, v1457.0);
                                                                                                    let v1635 = C::subsume(ctx, v1634);
                                                                                                    // Rule at src/opts/selects.isle line 89.
                                                                                                    returns.extend(Some(v1635));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Bmask => {
                                                                    if v2.0 == v1471.0 {
                                                                        let mut v1591 = C::inst_data_value_tupled_etor_returns::default();
                                                                        C::inst_data_value_tupled_etor(ctx, v84.1, &mut v1591);
                                                                        let mut v1591 = v1591.into_context_iter();
                                                                        while let Some(v1592) = v1591.next(ctx) {
                                                                            let v1593 = C::iconst_sextend_etor(ctx, v1592);
                                                                            if let Some(v1594) = v1593 {
                                                                                if v1594.1 == 1_i64 {
                                                                                    if v2.0 == v1594.0 {
                                                                                        let mut v1915 = C::inst_data_value_etor_returns::default();
                                                                                        C::inst_data_value_etor(ctx, v1622, &mut v1915);
                                                                                        let mut v1915 = v1915.into_context_iter();
                                                                                        while let Some(v1916) = v1915.next(ctx) {
                                                                                            if let &InstructionData::IntCompare {
                                                                                                opcode: ref v1919,
                                                                                                args: ref v1920,
                                                                                                cond: ref v1921,
                                                                                            } = &v1916.1 {
                                                                                                if let &Opcode::Icmp = v1919 {
                                                                                                    match v1921 {
                                                                                                        &IntCC::NotEqual => {
                                                                                                            if v89.0 == v1916.0 {
                                                                                                                let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                                                                let v1922 = C::unpack_value_array_2(ctx, v1920);
                                                                                                                if v1457.0 == v1922.0 {
                                                                                                                    if v1457.1 == v1922.1 {
                                                                                                                        let v1925 = constructor_spaceship_s(ctx, v89.0, v1457.0, v1457.1);
                                                                                                                        let v1926 = constructor_sextend_maybe(ctx, v2.0, v1925);
                                                                                                                        // Rule at src/opts/spaceship.isle line 133.
                                                                                                                        returns.extend(Some(v1926));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                        &IntCC::SignedLessThan => {
                                                                                                            if v89.0 == v1916.0 {
                                                                                                                let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                                                                let v1922 = C::unpack_value_array_2(ctx, v1920);
                                                                                                                if v1457.0 == v1922.0 {
                                                                                                                    if v1457.1 == v1922.1 {
                                                                                                                        let v1925 = constructor_spaceship_s(ctx, v89.0, v1457.0, v1457.1);
                                                                                                                        let v1926 = constructor_sextend_maybe(ctx, v2.0, v1925);
                                                                                                                        // Rule at src/opts/spaceship.isle line 123.
                                                                                                                        returns.extend(Some(v1926));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                        _ => {}
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                if v84.1 == v1457.0 {
                                                    if v84.2 == v1457.1 {
                                                        let v1604 = constructor_smax(ctx, v2.0, v1457.0, v1457.1);
                                                        // Rule at src/opts/selects.isle line 25.
                                                        returns.extend(Some(v1604));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v84.2 == v1457.0 {
                                                    if v84.1 == v1457.1 {
                                                        let v1606 = constructor_smin(ctx, v2.0, v1457.0, v1457.1);
                                                        // Rule at src/opts/selects.isle line 39.
                                                        returns.extend(Some(v1606));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::SignedGreaterThanOrEqual => {
                                                let mut v1470 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v84.2, &mut v1470);
                                                let mut v1470 = v1470.into_context_iter();
                                                while let Some(v1471) = v1470.next(ctx) {
                                                    match &v1471.1 {
                                                        &InstructionData::Unary {
                                                            opcode: ref v1621,
                                                            arg: v1622,
                                                        } => {
                                                            if let &Opcode::Ineg = v1621 {
                                                                if v2.0 == v1471.0 {
                                                                    let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                    if v84.1 == v1457.0 {
                                                                        if v84.1 == v1622 {
                                                                            let mut v1627 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v1457.1, &mut v1627);
                                                                            let mut v1627 = v1627.into_context_iter();
                                                                            while let Some(v1628) = v1627.next(ctx) {
                                                                                if let &InstructionData::UnaryImm {
                                                                                    opcode: ref v1631,
                                                                                    imm: v1632,
                                                                                } = &v1628.1 {
                                                                                    if let &Opcode::Iconst = v1631 {
                                                                                        let v1633 = C::u64_from_imm64(ctx, v1632);
                                                                                        if v1633 == 0x0_u64 {
                                                                                            if v2.0 == v1628.0 {
                                                                                                let v1634 = constructor_iabs(ctx, v2.0, v1457.0);
                                                                                                let v1635 = C::subsume(ctx, v1634);
                                                                                                // Rule at src/opts/selects.isle line 90.
                                                                                                returns.extend(Some(v1635));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::UnaryImm {
                                                            opcode: ref v1582,
                                                            imm: v1583,
                                                        } => {
                                                            if let &Opcode::Iconst = v1582 {
                                                                let v1584 = C::u64_from_imm64(ctx, v1583);
                                                                if v1584 == 0x1_u64 {
                                                                    if v2.0 == v1471.0 {
                                                                        let mut v94 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v84.1, &mut v94);
                                                                        let mut v94 = v94.into_context_iter();
                                                                        while let Some(v95) = v94.next(ctx) {
                                                                            if let &InstructionData::IntCompare {
                                                                                opcode: ref v1462,
                                                                                args: ref v1463,
                                                                                cond: ref v1464,
                                                                            } = &v95.1 {
                                                                                if let &Opcode::Icmp = v1462 {
                                                                                    match v1464 {
                                                                                        &IntCC::SignedGreaterThan => {
                                                                                            if v2.0 == v95.0 {
                                                                                                let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                                                let v1465 = C::unpack_value_array_2(ctx, v1463);
                                                                                                if v1457.0 == v1465.0 {
                                                                                                    if v1457.1 == v1465.1 {
                                                                                                        let v1721 = constructor_ne(ctx, v2.0, v1457.0, v1457.1);
                                                                                                        // Rule at src/opts/selects.isle line 163.
                                                                                                        returns.extend(Some(v1721));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                        &IntCC::SignedLessThan => {
                                                                                            if v2.0 == v95.0 {
                                                                                                let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                                                let v1465 = C::unpack_value_array_2(ctx, v1463);
                                                                                                if v1457.0 == v1465.1 {
                                                                                                    if v1457.1 == v1465.0 {
                                                                                                        let v1721 = constructor_ne(ctx, v2.0, v1457.0, v1457.1);
                                                                                                        // Rule at src/opts/selects.isle line 167.
                                                                                                        returns.extend(Some(v1721));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                        _ => {}
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                if v84.1 == v1457.0 {
                                                    if v84.2 == v1457.1 {
                                                        let v1604 = constructor_smax(ctx, v2.0, v1457.0, v1457.1);
                                                        // Rule at src/opts/selects.isle line 26.
                                                        returns.extend(Some(v1604));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v84.2 == v1457.0 {
                                                    if v84.1 == v1457.1 {
                                                        let v1606 = constructor_smin(ctx, v2.0, v1457.0, v1457.1);
                                                        // Rule at src/opts/selects.isle line 40.
                                                        returns.extend(Some(v1606));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::SignedLessThan => {
                                                let mut v94 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v84.1, &mut v94);
                                                let mut v94 = v94.into_context_iter();
                                                while let Some(v95) = v94.next(ctx) {
                                                    match &v95.1 {
                                                        &InstructionData::Unary {
                                                            opcode: ref v98,
                                                            arg: v99,
                                                        } => {
                                                            if let &Opcode::Ineg = v98 {
                                                                if v2.0 == v95.0 {
                                                                    if v84.2 == v99 {
                                                                        let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                        if v84.2 == v1457.0 {
                                                                            let mut v1627 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v1457.1, &mut v1627);
                                                                            let mut v1627 = v1627.into_context_iter();
                                                                            while let Some(v1628) = v1627.next(ctx) {
                                                                                if let &InstructionData::UnaryImm {
                                                                                    opcode: ref v1631,
                                                                                    imm: v1632,
                                                                                } = &v1628.1 {
                                                                                    if let &Opcode::Iconst = v1631 {
                                                                                        let v1633 = C::u64_from_imm64(ctx, v1632);
                                                                                        if v1633 == 0x0_u64 {
                                                                                            if v2.0 == v1628.0 {
                                                                                                let v1634 = constructor_iabs(ctx, v2.0, v1457.0);
                                                                                                let v1635 = C::subsume(ctx, v1634);
                                                                                                // Rule at src/opts/selects.isle line 92.
                                                                                                returns.extend(Some(v1635));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::UnaryImm {
                                                            opcode: ref v1579,
                                                            imm: v1580,
                                                        } => {
                                                            if let &Opcode::Iconst = v1579 {
                                                                let v1581 = C::u64_from_imm64(ctx, v1580);
                                                                if v1581 == 0x1_u64 {
                                                                    if v2.0 == v95.0 {
                                                                        let mut v1470 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v84.2, &mut v1470);
                                                                        let mut v1470 = v1470.into_context_iter();
                                                                        while let Some(v1471) = v1470.next(ctx) {
                                                                            if let &InstructionData::IntCompare {
                                                                                opcode: ref v1474,
                                                                                args: ref v1475,
                                                                                cond: ref v1476,
                                                                            } = &v1471.1 {
                                                                                if let &Opcode::Icmp = v1474 {
                                                                                    match v1476 {
                                                                                        &IntCC::SignedGreaterThan => {
                                                                                            if v2.0 == v1471.0 {
                                                                                                let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                                                let v1477 = C::unpack_value_array_2(ctx, v1475);
                                                                                                if v1457.0 == v1477.0 {
                                                                                                    if v1457.1 == v1477.1 {
                                                                                                        let v1721 = constructor_ne(ctx, v2.0, v1457.0, v1457.1);
                                                                                                        // Rule at src/opts/selects.isle line 162.
                                                                                                        returns.extend(Some(v1721));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                        &IntCC::SignedLessThan => {
                                                                                            if v2.0 == v1471.0 {
                                                                                                let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                                                let v1477 = C::unpack_value_array_2(ctx, v1475);
                                                                                                if v1457.0 == v1477.1 {
                                                                                                    if v1457.1 == v1477.0 {
                                                                                                        let v1721 = constructor_ne(ctx, v2.0, v1457.0, v1457.1);
                                                                                                        // Rule at src/opts/selects.isle line 166.
                                                                                                        returns.extend(Some(v1721));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                        _ => {}
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let mut v1591 = C::inst_data_value_tupled_etor_returns::default();
                                                C::inst_data_value_tupled_etor(ctx, v84.1, &mut v1591);
                                                let mut v1591 = v1591.into_context_iter();
                                                while let Some(v1592) = v1591.next(ctx) {
                                                    let v1593 = C::iconst_sextend_etor(ctx, v1592);
                                                    if let Some(v1594) = v1593 {
                                                        if v1594.1 == -1_i64 {
                                                            if v2.0 == v1594.0 {
                                                                let mut v1877 = C::uextend_maybe_etor_returns::default();
                                                                C::uextend_maybe_etor(ctx, v84.2, &mut v1877);
                                                                let mut v1877 = v1877.into_context_iter();
                                                                while let Some(v1878) = v1877.next(ctx) {
                                                                    if v2.0 == v1878.0 {
                                                                        let mut v1881 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v1878.1, &mut v1881);
                                                                        let mut v1881 = v1881.into_context_iter();
                                                                        while let Some(v1882) = v1881.next(ctx) {
                                                                            if let &InstructionData::IntCompare {
                                                                                opcode: ref v1885,
                                                                                args: ref v1886,
                                                                                cond: ref v1887,
                                                                            } = &v1882.1 {
                                                                                if let &Opcode::Icmp = v1885 {
                                                                                    match v1887 {
                                                                                        &IntCC::NotEqual => {
                                                                                            if v89.0 == v1882.0 {
                                                                                                let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                                                let v1888 = C::unpack_value_array_2(ctx, v1886);
                                                                                                if v1457.0 == v1888.0 {
                                                                                                    if v1457.1 == v1888.1 {
                                                                                                        let v1925 = constructor_spaceship_s(ctx, v89.0, v1457.0, v1457.1);
                                                                                                        let v1926 = constructor_sextend_maybe(ctx, v2.0, v1925);
                                                                                                        // Rule at src/opts/spaceship.isle line 77.
                                                                                                        returns.extend(Some(v1926));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                        &IntCC::SignedGreaterThan => {
                                                                                            if v89.0 == v1882.0 {
                                                                                                let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                                                let v1888 = C::unpack_value_array_2(ctx, v1886);
                                                                                                if v1457.0 == v1888.0 {
                                                                                                    if v1457.1 == v1888.1 {
                                                                                                        let v1925 = constructor_spaceship_s(ctx, v89.0, v1457.0, v1457.1);
                                                                                                        let v1926 = constructor_sextend_maybe(ctx, v2.0, v1925);
                                                                                                        // Rule at src/opts/spaceship.isle line 83.
                                                                                                        returns.extend(Some(v1926));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                        _ => {}
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                if v84.1 == v1457.0 {
                                                    if v84.2 == v1457.1 {
                                                        let v1606 = constructor_smin(ctx, v2.0, v1457.0, v1457.1);
                                                        // Rule at src/opts/selects.isle line 29.
                                                        returns.extend(Some(v1606));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v84.1 == v1457.1 {
                                                    if v84.2 == v1457.0 {
                                                        let v1604 = constructor_smax(ctx, v2.0, v1457.0, v1457.1);
                                                        // Rule at src/opts/selects.isle line 35.
                                                        returns.extend(Some(v1604));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::SignedLessThanOrEqual => {
                                                let mut v94 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v84.1, &mut v94);
                                                let mut v94 = v94.into_context_iter();
                                                while let Some(v95) = v94.next(ctx) {
                                                    match &v95.1 {
                                                        &InstructionData::IntCompare {
                                                            opcode: ref v1462,
                                                            args: ref v1463,
                                                            cond: ref v1464,
                                                        } => {
                                                            if let &Opcode::Icmp = v1462 {
                                                                match v1464 {
                                                                    &IntCC::SignedGreaterThan => {
                                                                        if v2.0 == v95.0 {
                                                                            let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                            let v1465 = C::unpack_value_array_2(ctx, v1463);
                                                                            if v1457.0 == v1465.1 {
                                                                                if v1457.1 == v1465.0 {
                                                                                    let mut v1470 = C::inst_data_value_etor_returns::default();
                                                                                    C::inst_data_value_etor(ctx, v84.2, &mut v1470);
                                                                                    let mut v1470 = v1470.into_context_iter();
                                                                                    while let Some(v1471) = v1470.next(ctx) {
                                                                                        if let &InstructionData::UnaryImm {
                                                                                            opcode: ref v1582,
                                                                                            imm: v1583,
                                                                                        } = &v1471.1 {
                                                                                            if let &Opcode::Iconst = v1582 {
                                                                                                let v1584 = C::u64_from_imm64(ctx, v1583);
                                                                                                if v1584 == 0x1_u64 {
                                                                                                    if v2.0 == v1471.0 {
                                                                                                        let v1722 = constructor_ne(ctx, v2.0, v1457.1, v1457.0);
                                                                                                        // Rule at src/opts/selects.isle line 165.
                                                                                                        returns.extend(Some(v1722));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedLessThan => {
                                                                        if v2.0 == v95.0 {
                                                                            let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                            let v1465 = C::unpack_value_array_2(ctx, v1463);
                                                                            if v1457.0 == v1465.0 {
                                                                                if v1457.1 == v1465.1 {
                                                                                    let mut v1470 = C::inst_data_value_etor_returns::default();
                                                                                    C::inst_data_value_etor(ctx, v84.2, &mut v1470);
                                                                                    let mut v1470 = v1470.into_context_iter();
                                                                                    while let Some(v1471) = v1470.next(ctx) {
                                                                                        if let &InstructionData::UnaryImm {
                                                                                            opcode: ref v1582,
                                                                                            imm: v1583,
                                                                                        } = &v1471.1 {
                                                                                            if let &Opcode::Iconst = v1582 {
                                                                                                let v1584 = C::u64_from_imm64(ctx, v1583);
                                                                                                if v1584 == 0x1_u64 {
                                                                                                    if v2.0 == v1471.0 {
                                                                                                        let v1722 = constructor_ne(ctx, v2.0, v1457.1, v1457.0);
                                                                                                        // Rule at src/opts/selects.isle line 169.
                                                                                                        returns.extend(Some(v1722));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v98,
                                                            arg: v99,
                                                        } => {
                                                            if let &Opcode::Ineg = v98 {
                                                                if v2.0 == v95.0 {
                                                                    if v84.2 == v99 {
                                                                        let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                        if v84.2 == v1457.0 {
                                                                            let mut v1627 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v1457.1, &mut v1627);
                                                                            let mut v1627 = v1627.into_context_iter();
                                                                            while let Some(v1628) = v1627.next(ctx) {
                                                                                if let &InstructionData::UnaryImm {
                                                                                    opcode: ref v1631,
                                                                                    imm: v1632,
                                                                                } = &v1628.1 {
                                                                                    if let &Opcode::Iconst = v1631 {
                                                                                        let v1633 = C::u64_from_imm64(ctx, v1632);
                                                                                        if v1633 == 0x0_u64 {
                                                                                            if v2.0 == v1628.0 {
                                                                                                let v1634 = constructor_iabs(ctx, v2.0, v1457.0);
                                                                                                let v1635 = C::subsume(ctx, v1634);
                                                                                                // Rule at src/opts/selects.isle line 91.
                                                                                                returns.extend(Some(v1635));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                if v84.1 == v1457.0 {
                                                    if v84.2 == v1457.1 {
                                                        let v1606 = constructor_smin(ctx, v2.0, v1457.0, v1457.1);
                                                        // Rule at src/opts/selects.isle line 30.
                                                        returns.extend(Some(v1606));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v84.1 == v1457.1 {
                                                    if v84.2 == v1457.0 {
                                                        let v1604 = constructor_smax(ctx, v2.0, v1457.0, v1457.1);
                                                        // Rule at src/opts/selects.isle line 36.
                                                        returns.extend(Some(v1604));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::UnsignedGreaterThan => {
                                                let mut v1470 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v84.2, &mut v1470);
                                                let mut v1470 = v1470.into_context_iter();
                                                while let Some(v1471) = v1470.next(ctx) {
                                                    match &v1471.1 {
                                                        &InstructionData::IntCompare {
                                                            opcode: ref v1474,
                                                            args: ref v1475,
                                                            cond: ref v1476,
                                                        } => {
                                                            if let &Opcode::Icmp = v1474 {
                                                                match v1476 {
                                                                    &IntCC::Equal => {
                                                                        if v2.0 == v1471.0 {
                                                                            let mut v94 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v84.1, &mut v94);
                                                                            let mut v94 = v94.into_context_iter();
                                                                            while let Some(v95) = v94.next(ctx) {
                                                                                if let &InstructionData::UnaryImm {
                                                                                    opcode: ref v1579,
                                                                                    imm: v1580,
                                                                                } = &v95.1 {
                                                                                    if let &Opcode::Iconst = v1579 {
                                                                                        let v1581 = C::u64_from_imm64(ctx, v1580);
                                                                                        if v1581 == 0x1_u64 {
                                                                                            if v2.0 == v95.0 {
                                                                                                let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                                                let v1477 = C::unpack_value_array_2(ctx, v1475);
                                                                                                if v1457.0 == v1477.0 {
                                                                                                    if v1457.1 == v1477.1 {
                                                                                                        let v1720 = constructor_ule(ctx, v2.0, v1457.1, v1457.0);
                                                                                                        // Rule at src/opts/selects.isle line 157.
                                                                                                        returns.extend(Some(v1720));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                                if v1457.0 == v1477.1 {
                                                                                                    if v1457.1 == v1477.0 {
                                                                                                        let v1720 = constructor_ule(ctx, v2.0, v1457.1, v1457.0);
                                                                                                        // Rule at src/opts/selects.isle line 153.
                                                                                                        returns.extend(Some(v1720));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedGreaterThan => {
                                                                        if v2.0 == v1471.0 {
                                                                            let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                            let v1477 = C::unpack_value_array_2(ctx, v1475);
                                                                            if v1457.0 == v1477.1 {
                                                                                if v1457.1 == v1477.0 {
                                                                                    let mut v94 = C::inst_data_value_etor_returns::default();
                                                                                    C::inst_data_value_etor(ctx, v84.1, &mut v94);
                                                                                    let mut v94 = v94.into_context_iter();
                                                                                    while let Some(v95) = v94.next(ctx) {
                                                                                        if let &InstructionData::UnaryImm {
                                                                                            opcode: ref v1579,
                                                                                            imm: v1580,
                                                                                        } = &v95.1 {
                                                                                            if let &Opcode::Iconst = v1579 {
                                                                                                let v1581 = C::u64_from_imm64(ctx, v1580);
                                                                                                if v1581 == 0x1_u64 {
                                                                                                    if v2.0 == v95.0 {
                                                                                                        let v1722 = constructor_ne(ctx, v2.0, v1457.1, v1457.0);
                                                                                                        // Rule at src/opts/selects.isle line 172.
                                                                                                        returns.extend(Some(v1722));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        if v2.0 == v1471.0 {
                                                                            let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                            let v1477 = C::unpack_value_array_2(ctx, v1475);
                                                                            if v1457.0 == v1477.0 {
                                                                                if v1457.1 == v1477.1 {
                                                                                    let mut v94 = C::inst_data_value_etor_returns::default();
                                                                                    C::inst_data_value_etor(ctx, v84.1, &mut v94);
                                                                                    let mut v94 = v94.into_context_iter();
                                                                                    while let Some(v95) = v94.next(ctx) {
                                                                                        if let &InstructionData::UnaryImm {
                                                                                            opcode: ref v1579,
                                                                                            imm: v1580,
                                                                                        } = &v95.1 {
                                                                                            if let &Opcode::Iconst = v1579 {
                                                                                                let v1581 = C::u64_from_imm64(ctx, v1580);
                                                                                                if v1581 == 0x1_u64 {
                                                                                                    if v2.0 == v95.0 {
                                                                                                        let v1722 = constructor_ne(ctx, v2.0, v1457.1, v1457.0);
                                                                                                        // Rule at src/opts/selects.isle line 176.
                                                                                                        returns.extend(Some(v1722));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v1621,
                                                            arg: v1622,
                                                        } => {
                                                            match v1621 {
                                                                &Opcode::Ineg => {
                                                                    if v89.0 == v1471.0 {
                                                                        let mut v1591 = C::inst_data_value_tupled_etor_returns::default();
                                                                        C::inst_data_value_tupled_etor(ctx, v84.1, &mut v1591);
                                                                        let mut v1591 = v1591.into_context_iter();
                                                                        while let Some(v1592) = v1591.next(ctx) {
                                                                            let v1593 = C::iconst_sextend_etor(ctx, v1592);
                                                                            if let Some(v1594) = v1593 {
                                                                                if v1594.1 == 1_i64 {
                                                                                    if v2.0 == v1594.0 {
                                                                                        let mut v1915 = C::inst_data_value_etor_returns::default();
                                                                                        C::inst_data_value_etor(ctx, v1622, &mut v1915);
                                                                                        let mut v1915 = v1915.into_context_iter();
                                                                                        while let Some(v1916) = v1915.next(ctx) {
                                                                                            if let &InstructionData::IntCompare {
                                                                                                opcode: ref v1919,
                                                                                                args: ref v1920,
                                                                                                cond: ref v1921,
                                                                                            } = &v1916.1 {
                                                                                                if let &Opcode::Icmp = v1919 {
                                                                                                    match v1921 {
                                                                                                        &IntCC::NotEqual => {
                                                                                                            if v89.0 == v1916.0 {
                                                                                                                let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                                                                let v1922 = C::unpack_value_array_2(ctx, v1920);
                                                                                                                if v1457.0 == v1922.0 {
                                                                                                                    if v1457.1 == v1922.1 {
                                                                                                                        let v1891 = constructor_spaceship_u(ctx, v89.0, v1457.0, v1457.1);
                                                                                                                        let v1892 = constructor_sextend_maybe(ctx, v2.0, v1891);
                                                                                                                        // Rule at src/opts/spaceship.isle line 64.
                                                                                                                        returns.extend(Some(v1892));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                        &IntCC::UnsignedLessThan => {
                                                                                                            if v89.0 == v1916.0 {
                                                                                                                let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                                                                let v1922 = C::unpack_value_array_2(ctx, v1920);
                                                                                                                if v1457.0 == v1922.0 {
                                                                                                                    if v1457.1 == v1922.1 {
                                                                                                                        let v1891 = constructor_spaceship_u(ctx, v89.0, v1457.0, v1457.1);
                                                                                                                        let v1892 = constructor_sextend_maybe(ctx, v2.0, v1891);
                                                                                                                        // Rule at src/opts/spaceship.isle line 54.
                                                                                                                        returns.extend(Some(v1892));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                        _ => {}
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Bmask => {
                                                                    if v2.0 == v1471.0 {
                                                                        let mut v1591 = C::inst_data_value_tupled_etor_returns::default();
                                                                        C::inst_data_value_tupled_etor(ctx, v84.1, &mut v1591);
                                                                        let mut v1591 = v1591.into_context_iter();
                                                                        while let Some(v1592) = v1591.next(ctx) {
                                                                            let v1593 = C::iconst_sextend_etor(ctx, v1592);
                                                                            if let Some(v1594) = v1593 {
                                                                                if v1594.1 == 1_i64 {
                                                                                    if v2.0 == v1594.0 {
                                                                                        let mut v1915 = C::inst_data_value_etor_returns::default();
                                                                                        C::inst_data_value_etor(ctx, v1622, &mut v1915);
                                                                                        let mut v1915 = v1915.into_context_iter();
                                                                                        while let Some(v1916) = v1915.next(ctx) {
                                                                                            if let &InstructionData::IntCompare {
                                                                                                opcode: ref v1919,
                                                                                                args: ref v1920,
                                                                                                cond: ref v1921,
                                                                                            } = &v1916.1 {
                                                                                                if let &Opcode::Icmp = v1919 {
                                                                                                    match v1921 {
                                                                                                        &IntCC::NotEqual => {
                                                                                                            if v89.0 == v1916.0 {
                                                                                                                let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                                                                let v1922 = C::unpack_value_array_2(ctx, v1920);
                                                                                                                if v1457.0 == v1922.0 {
                                                                                                                    if v1457.1 == v1922.1 {
                                                                                                                        let v1891 = constructor_spaceship_u(ctx, v89.0, v1457.0, v1457.1);
                                                                                                                        let v1892 = constructor_sextend_maybe(ctx, v2.0, v1891);
                                                                                                                        // Rule at src/opts/spaceship.isle line 68.
                                                                                                                        returns.extend(Some(v1892));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                        &IntCC::UnsignedLessThan => {
                                                                                                            if v89.0 == v1916.0 {
                                                                                                                let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                                                                let v1922 = C::unpack_value_array_2(ctx, v1920);
                                                                                                                if v1457.0 == v1922.0 {
                                                                                                                    if v1457.1 == v1922.1 {
                                                                                                                        let v1891 = constructor_spaceship_u(ctx, v89.0, v1457.0, v1457.1);
                                                                                                                        let v1892 = constructor_sextend_maybe(ctx, v2.0, v1891);
                                                                                                                        // Rule at src/opts/spaceship.isle line 58.
                                                                                                                        returns.extend(Some(v1892));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                        _ => {}
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                if v84.1 == v1457.0 {
                                                    if v84.2 == v1457.1 {
                                                        let v1605 = constructor_umax(ctx, v2.0, v1457.0, v1457.1);
                                                        // Rule at src/opts/selects.isle line 27.
                                                        returns.extend(Some(v1605));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v84.2 == v1457.0 {
                                                    if v84.1 == v1457.1 {
                                                        let v1607 = constructor_umin(ctx, v2.0, v1457.0, v1457.1);
                                                        // Rule at src/opts/selects.isle line 41.
                                                        returns.extend(Some(v1607));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::UnsignedGreaterThanOrEqual => {
                                                let mut v94 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v84.1, &mut v94);
                                                let mut v94 = v94.into_context_iter();
                                                while let Some(v95) = v94.next(ctx) {
                                                    if let &InstructionData::IntCompare {
                                                        opcode: ref v1462,
                                                        args: ref v1463,
                                                        cond: ref v1464,
                                                    } = &v95.1 {
                                                        if let &Opcode::Icmp = v1462 {
                                                            match v1464 {
                                                                &IntCC::Equal => {
                                                                    if v2.0 == v95.0 {
                                                                        let mut v1470 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v84.2, &mut v1470);
                                                                        let mut v1470 = v1470.into_context_iter();
                                                                        while let Some(v1471) = v1470.next(ctx) {
                                                                            if let &InstructionData::UnaryImm {
                                                                                opcode: ref v1582,
                                                                                imm: v1583,
                                                                            } = &v1471.1 {
                                                                                if let &Opcode::Iconst = v1582 {
                                                                                    let v1584 = C::u64_from_imm64(ctx, v1583);
                                                                                    if v1584 == 0x1_u64 {
                                                                                        if v2.0 == v1471.0 {
                                                                                            let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                                            let v1465 = C::unpack_value_array_2(ctx, v1463);
                                                                                            if v1457.0 == v1465.0 {
                                                                                                if v1457.1 == v1465.1 {
                                                                                                    let v1719 = constructor_ule(ctx, v2.0, v1457.0, v1457.1);
                                                                                                    // Rule at src/opts/selects.isle line 152.
                                                                                                    returns.extend(Some(v1719));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                            if v1457.0 == v1465.1 {
                                                                                                if v1457.1 == v1465.0 {
                                                                                                    let v1719 = constructor_ule(ctx, v2.0, v1457.0, v1457.1);
                                                                                                    // Rule at src/opts/selects.isle line 156.
                                                                                                    returns.extend(Some(v1719));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &IntCC::UnsignedGreaterThan => {
                                                                    if v2.0 == v95.0 {
                                                                        let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                        let v1465 = C::unpack_value_array_2(ctx, v1463);
                                                                        if v1457.0 == v1465.0 {
                                                                            if v1457.1 == v1465.1 {
                                                                                let mut v1470 = C::inst_data_value_etor_returns::default();
                                                                                C::inst_data_value_etor(ctx, v84.2, &mut v1470);
                                                                                let mut v1470 = v1470.into_context_iter();
                                                                                while let Some(v1471) = v1470.next(ctx) {
                                                                                    if let &InstructionData::UnaryImm {
                                                                                        opcode: ref v1582,
                                                                                        imm: v1583,
                                                                                    } = &v1471.1 {
                                                                                        if let &Opcode::Iconst = v1582 {
                                                                                            let v1584 = C::u64_from_imm64(ctx, v1583);
                                                                                            if v1584 == 0x1_u64 {
                                                                                                if v2.0 == v1471.0 {
                                                                                                    let v1721 = constructor_ne(ctx, v2.0, v1457.0, v1457.1);
                                                                                                    // Rule at src/opts/selects.isle line 171.
                                                                                                    returns.extend(Some(v1721));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &IntCC::UnsignedLessThan => {
                                                                    if v2.0 == v95.0 {
                                                                        let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                        let v1465 = C::unpack_value_array_2(ctx, v1463);
                                                                        if v1457.0 == v1465.1 {
                                                                            if v1457.1 == v1465.0 {
                                                                                let mut v1470 = C::inst_data_value_etor_returns::default();
                                                                                C::inst_data_value_etor(ctx, v84.2, &mut v1470);
                                                                                let mut v1470 = v1470.into_context_iter();
                                                                                while let Some(v1471) = v1470.next(ctx) {
                                                                                    if let &InstructionData::UnaryImm {
                                                                                        opcode: ref v1582,
                                                                                        imm: v1583,
                                                                                    } = &v1471.1 {
                                                                                        if let &Opcode::Iconst = v1582 {
                                                                                            let v1584 = C::u64_from_imm64(ctx, v1583);
                                                                                            if v1584 == 0x1_u64 {
                                                                                                if v2.0 == v1471.0 {
                                                                                                    let v1721 = constructor_ne(ctx, v2.0, v1457.0, v1457.1);
                                                                                                    // Rule at src/opts/selects.isle line 175.
                                                                                                    returns.extend(Some(v1721));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                    }
                                                }
                                                let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                if v84.1 == v1457.0 {
                                                    if v84.2 == v1457.1 {
                                                        let v1605 = constructor_umax(ctx, v2.0, v1457.0, v1457.1);
                                                        // Rule at src/opts/selects.isle line 28.
                                                        returns.extend(Some(v1605));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v84.1 == v1457.1 {
                                                    if v84.2 == v1457.0 {
                                                        let v1607 = constructor_umin(ctx, v2.0, v1457.0, v1457.1);
                                                        // Rule at src/opts/selects.isle line 42.
                                                        returns.extend(Some(v1607));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::UnsignedLessThan => {
                                                let mut v94 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v84.1, &mut v94);
                                                let mut v94 = v94.into_context_iter();
                                                while let Some(v95) = v94.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v1579,
                                                        imm: v1580,
                                                    } = &v95.1 {
                                                        if let &Opcode::Iconst = v1579 {
                                                            let v1581 = C::u64_from_imm64(ctx, v1580);
                                                            if v1581 == 0x1_u64 {
                                                                if v2.0 == v95.0 {
                                                                    let mut v1470 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v84.2, &mut v1470);
                                                                    let mut v1470 = v1470.into_context_iter();
                                                                    while let Some(v1471) = v1470.next(ctx) {
                                                                        if let &InstructionData::IntCompare {
                                                                            opcode: ref v1474,
                                                                            args: ref v1475,
                                                                            cond: ref v1476,
                                                                        } = &v1471.1 {
                                                                            if let &Opcode::Icmp = v1474 {
                                                                                match v1476 {
                                                                                    &IntCC::Equal => {
                                                                                        if v2.0 == v1471.0 {
                                                                                            let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                                            let v1477 = C::unpack_value_array_2(ctx, v1475);
                                                                                            if v1457.0 == v1477.0 {
                                                                                                if v1457.1 == v1477.1 {
                                                                                                    let v1719 = constructor_ule(ctx, v2.0, v1457.0, v1457.1);
                                                                                                    // Rule at src/opts/selects.isle line 151.
                                                                                                    returns.extend(Some(v1719));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                            if v1457.0 == v1477.1 {
                                                                                                if v1457.1 == v1477.0 {
                                                                                                    let v1719 = constructor_ule(ctx, v2.0, v1457.0, v1457.1);
                                                                                                    // Rule at src/opts/selects.isle line 155.
                                                                                                    returns.extend(Some(v1719));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                    &IntCC::UnsignedGreaterThan => {
                                                                                        if v2.0 == v1471.0 {
                                                                                            let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                                            let v1477 = C::unpack_value_array_2(ctx, v1475);
                                                                                            if v1457.0 == v1477.0 {
                                                                                                if v1457.1 == v1477.1 {
                                                                                                    let v1721 = constructor_ne(ctx, v2.0, v1457.0, v1457.1);
                                                                                                    // Rule at src/opts/selects.isle line 170.
                                                                                                    returns.extend(Some(v1721));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                    &IntCC::UnsignedLessThan => {
                                                                                        if v2.0 == v1471.0 {
                                                                                            let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                                            let v1477 = C::unpack_value_array_2(ctx, v1475);
                                                                                            if v1457.0 == v1477.1 {
                                                                                                if v1457.1 == v1477.0 {
                                                                                                    let v1721 = constructor_ne(ctx, v2.0, v1457.0, v1457.1);
                                                                                                    // Rule at src/opts/selects.isle line 174.
                                                                                                    returns.extend(Some(v1721));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                    _ => {}
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                let mut v1591 = C::inst_data_value_tupled_etor_returns::default();
                                                C::inst_data_value_tupled_etor(ctx, v84.1, &mut v1591);
                                                let mut v1591 = v1591.into_context_iter();
                                                while let Some(v1592) = v1591.next(ctx) {
                                                    let v1593 = C::iconst_sextend_etor(ctx, v1592);
                                                    if let Some(v1594) = v1593 {
                                                        if v1594.1 == -1_i64 {
                                                            if v2.0 == v1594.0 {
                                                                let mut v1877 = C::uextend_maybe_etor_returns::default();
                                                                C::uextend_maybe_etor(ctx, v84.2, &mut v1877);
                                                                let mut v1877 = v1877.into_context_iter();
                                                                while let Some(v1878) = v1877.next(ctx) {
                                                                    if v2.0 == v1878.0 {
                                                                        let mut v1881 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v1878.1, &mut v1881);
                                                                        let mut v1881 = v1881.into_context_iter();
                                                                        while let Some(v1882) = v1881.next(ctx) {
                                                                            if let &InstructionData::IntCompare {
                                                                                opcode: ref v1885,
                                                                                args: ref v1886,
                                                                                cond: ref v1887,
                                                                            } = &v1882.1 {
                                                                                if let &Opcode::Icmp = v1885 {
                                                                                    match v1887 {
                                                                                        &IntCC::NotEqual => {
                                                                                            if v89.0 == v1882.0 {
                                                                                                let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                                                let v1888 = C::unpack_value_array_2(ctx, v1886);
                                                                                                if v1457.0 == v1888.0 {
                                                                                                    if v1457.1 == v1888.1 {
                                                                                                        let v1891 = constructor_spaceship_u(ctx, v89.0, v1457.0, v1457.1);
                                                                                                        let v1892 = constructor_sextend_maybe(ctx, v2.0, v1891);
                                                                                                        // Rule at src/opts/spaceship.isle line 12.
                                                                                                        returns.extend(Some(v1892));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                        &IntCC::UnsignedGreaterThan => {
                                                                                            if v89.0 == v1882.0 {
                                                                                                let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                                                let v1888 = C::unpack_value_array_2(ctx, v1886);
                                                                                                if v1457.0 == v1888.0 {
                                                                                                    if v1457.1 == v1888.1 {
                                                                                                        let v1891 = constructor_spaceship_u(ctx, v89.0, v1457.0, v1457.1);
                                                                                                        let v1892 = constructor_sextend_maybe(ctx, v2.0, v1891);
                                                                                                        // Rule at src/opts/spaceship.isle line 18.
                                                                                                        returns.extend(Some(v1892));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                        _ => {}
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                if v84.1 == v1457.0 {
                                                    if v84.2 == v1457.1 {
                                                        let v1607 = constructor_umin(ctx, v2.0, v1457.0, v1457.1);
                                                        // Rule at src/opts/selects.isle line 31.
                                                        returns.extend(Some(v1607));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v84.1 == v1457.1 {
                                                    if v84.2 == v1457.0 {
                                                        let v1605 = constructor_umax(ctx, v2.0, v1457.0, v1457.1);
                                                        // Rule at src/opts/selects.isle line 37.
                                                        returns.extend(Some(v1605));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::UnsignedLessThanOrEqual => {
                                                let mut v94 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v84.1, &mut v94);
                                                let mut v94 = v94.into_context_iter();
                                                while let Some(v95) = v94.next(ctx) {
                                                    if let &InstructionData::IntCompare {
                                                        opcode: ref v1462,
                                                        args: ref v1463,
                                                        cond: ref v1464,
                                                    } = &v95.1 {
                                                        if let &Opcode::Icmp = v1462 {
                                                            match v1464 {
                                                                &IntCC::Equal => {
                                                                    if v2.0 == v95.0 {
                                                                        let mut v1470 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v84.2, &mut v1470);
                                                                        let mut v1470 = v1470.into_context_iter();
                                                                        while let Some(v1471) = v1470.next(ctx) {
                                                                            if let &InstructionData::UnaryImm {
                                                                                opcode: ref v1582,
                                                                                imm: v1583,
                                                                            } = &v1471.1 {
                                                                                if let &Opcode::Iconst = v1582 {
                                                                                    let v1584 = C::u64_from_imm64(ctx, v1583);
                                                                                    if v1584 == 0x1_u64 {
                                                                                        if v2.0 == v1471.0 {
                                                                                            let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                                            let v1465 = C::unpack_value_array_2(ctx, v1463);
                                                                                            if v1457.0 == v1465.0 {
                                                                                                if v1457.1 == v1465.1 {
                                                                                                    let v1720 = constructor_ule(ctx, v2.0, v1457.1, v1457.0);
                                                                                                    // Rule at src/opts/selects.isle line 158.
                                                                                                    returns.extend(Some(v1720));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                            if v1457.0 == v1465.1 {
                                                                                                if v1457.1 == v1465.0 {
                                                                                                    let v1720 = constructor_ule(ctx, v2.0, v1457.1, v1457.0);
                                                                                                    // Rule at src/opts/selects.isle line 154.
                                                                                                    returns.extend(Some(v1720));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &IntCC::UnsignedGreaterThan => {
                                                                    if v2.0 == v95.0 {
                                                                        let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                        let v1465 = C::unpack_value_array_2(ctx, v1463);
                                                                        if v1457.0 == v1465.1 {
                                                                            if v1457.1 == v1465.0 {
                                                                                let mut v1470 = C::inst_data_value_etor_returns::default();
                                                                                C::inst_data_value_etor(ctx, v84.2, &mut v1470);
                                                                                let mut v1470 = v1470.into_context_iter();
                                                                                while let Some(v1471) = v1470.next(ctx) {
                                                                                    if let &InstructionData::UnaryImm {
                                                                                        opcode: ref v1582,
                                                                                        imm: v1583,
                                                                                    } = &v1471.1 {
                                                                                        if let &Opcode::Iconst = v1582 {
                                                                                            let v1584 = C::u64_from_imm64(ctx, v1583);
                                                                                            if v1584 == 0x1_u64 {
                                                                                                if v2.0 == v1471.0 {
                                                                                                    let v1722 = constructor_ne(ctx, v2.0, v1457.1, v1457.0);
                                                                                                    // Rule at src/opts/selects.isle line 173.
                                                                                                    returns.extend(Some(v1722));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &IntCC::UnsignedLessThan => {
                                                                    if v2.0 == v95.0 {
                                                                        let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                        let v1465 = C::unpack_value_array_2(ctx, v1463);
                                                                        if v1457.0 == v1465.0 {
                                                                            if v1457.1 == v1465.1 {
                                                                                let mut v1470 = C::inst_data_value_etor_returns::default();
                                                                                C::inst_data_value_etor(ctx, v84.2, &mut v1470);
                                                                                let mut v1470 = v1470.into_context_iter();
                                                                                while let Some(v1471) = v1470.next(ctx) {
                                                                                    if let &InstructionData::UnaryImm {
                                                                                        opcode: ref v1582,
                                                                                        imm: v1583,
                                                                                    } = &v1471.1 {
                                                                                        if let &Opcode::Iconst = v1582 {
                                                                                            let v1584 = C::u64_from_imm64(ctx, v1583);
                                                                                            if v1584 == 0x1_u64 {
                                                                                                if v2.0 == v1471.0 {
                                                                                                    let v1722 = constructor_ne(ctx, v2.0, v1457.1, v1457.0);
                                                                                                    // Rule at src/opts/selects.isle line 177.
                                                                                                    returns.extend(Some(v1722));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                    }
                                                }
                                                let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                if v84.1 == v1457.0 {
                                                    if v84.2 == v1457.1 {
                                                        let v1607 = constructor_umin(ctx, v2.0, v1457.0, v1457.1);
                                                        // Rule at src/opts/selects.isle line 32.
                                                        returns.extend(Some(v1607));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v84.1 == v1457.1 {
                                                    if v84.2 == v1457.0 {
                                                        let v1605 = constructor_umax(ctx, v2.0, v1457.0, v1457.1);
                                                        // Rule at src/opts/selects.isle line 38.
                                                        returns.extend(Some(v1605));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                        let mut v94 = C::inst_data_value_etor_returns::default();
                                        C::inst_data_value_etor(ctx, v84.1, &mut v94);
                                        let mut v94 = v94.into_context_iter();
                                        while let Some(v95) = v94.next(ctx) {
                                            if let &InstructionData::UnaryImm {
                                                opcode: ref v1579,
                                                imm: v1580,
                                            } = &v95.1 {
                                                if let &Opcode::Iconst = v1579 {
                                                    let v1581 = C::u64_from_imm64(ctx, v1580);
                                                    match v1581 {
                                                        0x0_u64 => {
                                                            let mut v1470 = C::inst_data_value_etor_returns::default();
                                                            C::inst_data_value_etor(ctx, v84.2, &mut v1470);
                                                            let mut v1470 = v1470.into_context_iter();
                                                            while let Some(v1471) = v1470.next(ctx) {
                                                                if let &InstructionData::UnaryImm {
                                                                    opcode: ref v1582,
                                                                    imm: v1583,
                                                                } = &v1471.1 {
                                                                    if let &Opcode::Iconst = v1582 {
                                                                        let v1584 = C::u64_from_imm64(ctx, v1583);
                                                                        let v1585 = C::u64_matches_non_zero(ctx, v1584);
                                                                        if let Some(v1586) = v1585 {
                                                                            if v1586 == true {
                                                                                let v1587 = &C::intcc_complement(ctx, v1456);
                                                                                let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                                                let v1588 = constructor_icmp(ctx, v89.0, v1587, v1457.0, v1457.1);
                                                                                let v1589 = constructor_select(ctx, v2.0, v1588, v84.2, v84.1);
                                                                                // Rule at src/opts/selects.isle line 8.
                                                                                returns.extend(Some(v1589));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        0x1_u64 => {
                                                            let mut v1470 = C::inst_data_value_etor_returns::default();
                                                            C::inst_data_value_etor(ctx, v84.2, &mut v1470);
                                                            let mut v1470 = v1470.into_context_iter();
                                                            while let Some(v1471) = v1470.next(ctx) {
                                                                if let &InstructionData::UnaryImm {
                                                                    opcode: ref v1582,
                                                                    imm: v1583,
                                                                } = &v1471.1 {
                                                                    if let &Opcode::Iconst = v1582 {
                                                                        let v1584 = C::u64_from_imm64(ctx, v1583);
                                                                        if v1584 == 0x0_u64 {
                                                                            let v1590 = constructor_uextend_maybe(ctx, v2.0, v84.0);
                                                                            // Rule at src/opts/selects.isle line 14.
                                                                            returns.extend(Some(v1590));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                            }
                                        }
                                        let mut v1591 = C::inst_data_value_tupled_etor_returns::default();
                                        C::inst_data_value_tupled_etor(ctx, v84.1, &mut v1591);
                                        let mut v1591 = v1591.into_context_iter();
                                        while let Some(v1592) = v1591.next(ctx) {
                                            let v1593 = C::iconst_sextend_etor(ctx, v1592);
                                            if let Some(v1594) = v1593 {
                                                if v1594.1 == -1_i64 {
                                                    let mut v1597 = C::inst_data_value_tupled_etor_returns::default();
                                                    C::inst_data_value_tupled_etor(ctx, v84.2, &mut v1597);
                                                    let mut v1597 = v1597.into_context_iter();
                                                    while let Some(v1598) = v1597.next(ctx) {
                                                        let v1599 = C::iconst_sextend_etor(ctx, v1598);
                                                        if let Some(v1600) = v1599 {
                                                            if v1600.1 == 0_i64 {
                                                                let v1603 = constructor_bmask(ctx, v2.0, v84.0);
                                                                // Rule at src/opts/selects.isle line 19.
                                                                returns.extend(Some(v1603));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v92,
                                    arg: v93,
                                } => {
                                    if let &Opcode::Uextend = v92 {
                                        let mut v1407 = C::inst_data_value_etor_returns::default();
                                        C::inst_data_value_etor(ctx, v93, &mut v1407);
                                        let mut v1407 = v1407.into_context_iter();
                                        while let Some(v1408) = v1407.next(ctx) {
                                            if let &InstructionData::IntCompare {
                                                opcode: ref v1411,
                                                args: ref v1412,
                                                cond: ref v1413,
                                            } = &v1408.1 {
                                                if let &Opcode::Icmp = v1411 {
                                                    let v1417 = constructor_select(ctx, v2.0, v93, v84.1, v84.2);
                                                    // Rule at src/opts/icmp.isle line 83.
                                                    returns.extend(Some(v1417));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v1030,
                                    imm: v1031,
                                } => {
                                    if let &Opcode::Iconst = v1030 {
                                        let v1032 = C::u64_from_imm64(ctx, v1031);
                                        if v1032 == 0x0_u64 {
                                            let v1036 = C::subsume(ctx, v84.2);
                                            // Rule at src/opts/cprop.isle line 228.
                                            returns.extend(Some(v1036));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        let v1033 = C::u64_matches_non_zero(ctx, v1032);
                                        if let Some(v1034) = v1033 {
                                            if v1034 == true {
                                                let v1035 = C::subsume(ctx, v84.1);
                                                // Rule at src/opts/cprop.isle line 226.
                                                returns.extend(Some(v1035));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                        let mut v94 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v84.1, &mut v94);
                        let mut v94 = v94.into_context_iter();
                        while let Some(v95) = v94.next(ctx) {
                            match &v95.1 {
                                &InstructionData::IntCompare {
                                    opcode: ref v1462,
                                    args: ref v1463,
                                    cond: ref v1464,
                                } => {
                                    if let &Opcode::Icmp = v1462 {
                                        if let &IntCC::Equal = v1464 {
                                            if v2.0 == v95.0 {
                                                let mut v1470 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v84.2, &mut v1470);
                                                let mut v1470 = v1470.into_context_iter();
                                                while let Some(v1471) = v1470.next(ctx) {
                                                    if let &InstructionData::IntCompare {
                                                        opcode: ref v1474,
                                                        args: ref v1475,
                                                        cond: ref v1476,
                                                    } = &v1471.1 {
                                                        if let &Opcode::Icmp = v1474 {
                                                            if let &IntCC::Equal = v1476 {
                                                                if v2.0 == v1471.0 {
                                                                    let v1477 = C::unpack_value_array_2(ctx, v1475);
                                                                    let mut v1748 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v1477.0, &mut v1748);
                                                                    let mut v1748 = v1748.into_context_iter();
                                                                    while let Some(v1749) = v1748.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v1752,
                                                                            imm: v1753,
                                                                        } = &v1749.1 {
                                                                            if let &Opcode::Iconst = v1752 {
                                                                                let v1465 = C::unpack_value_array_2(ctx, v1463);
                                                                                if v1465.0 == v1477.1 {
                                                                                    let v1754 = C::u64_from_imm64(ctx, v1753);
                                                                                    let v1755 = constructor_iconst_u(ctx, v1749.0, v1754);
                                                                                    let v1768 = constructor_select(ctx, v1749.0, v84.0, v1465.1, v1755);
                                                                                    let v1769 = constructor_eq(ctx, v2.0, v1465.0, v1768);
                                                                                    // Rule at src/opts/selects.isle line 193.
                                                                                    returns.extend(Some(v1769));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                                if v1465.1 == v1477.1 {
                                                                                    let v1754 = C::u64_from_imm64(ctx, v1753);
                                                                                    let v1755 = constructor_iconst_u(ctx, v1749.0, v1754);
                                                                                    let v1756 = constructor_select(ctx, v1749.0, v84.0, v1465.0, v1755);
                                                                                    let v1757 = constructor_eq(ctx, v2.0, v1465.1, v1756);
                                                                                    // Rule at src/opts/selects.isle line 191.
                                                                                    returns.extend(Some(v1757));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    let mut v1758 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v1477.1, &mut v1758);
                                                                    let mut v1758 = v1758.into_context_iter();
                                                                    while let Some(v1759) = v1758.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v1762,
                                                                            imm: v1763,
                                                                        } = &v1759.1 {
                                                                            if let &Opcode::Iconst = v1762 {
                                                                                let v1465 = C::unpack_value_array_2(ctx, v1463);
                                                                                if v1465.0 == v1477.0 {
                                                                                    let v1764 = C::u64_from_imm64(ctx, v1763);
                                                                                    let v1765 = constructor_iconst_u(ctx, v1759.0, v1764);
                                                                                    let v1770 = constructor_select(ctx, v1759.0, v84.0, v1465.1, v1765);
                                                                                    let v1771 = constructor_eq(ctx, v2.0, v1465.0, v1770);
                                                                                    // Rule at src/opts/selects.isle line 194.
                                                                                    returns.extend(Some(v1771));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                                if v1465.1 == v1477.0 {
                                                                                    let v1764 = C::u64_from_imm64(ctx, v1763);
                                                                                    let v1765 = constructor_iconst_u(ctx, v1759.0, v1764);
                                                                                    let v1766 = constructor_select(ctx, v1759.0, v84.0, v1465.0, v1765);
                                                                                    let v1767 = constructor_eq(ctx, v2.0, v1465.1, v1766);
                                                                                    // Rule at src/opts/selects.isle line 192.
                                                                                    returns.extend(Some(v1767));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::Ternary {
                                    opcode: ref v1666,
                                    args: ref v1667,
                                } => {
                                    if let &Opcode::Select = v1666 {
                                        if v2.0 == v95.0 {
                                            let v1668 = C::unpack_value_array_3(ctx, v1667);
                                            if v84.0 == v1668.0 {
                                                let v1672 = constructor_select(ctx, v2.0, v84.0, v1668.1, v84.2);
                                                // Rule at src/opts/selects.isle line 102.
                                                returns.extend(Some(v1672));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v98,
                                    arg: v99,
                                } => {
                                    match v98 {
                                        &Opcode::Uextend => {
                                            if v2.0 == v95.0 {
                                                let mut v1470 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v84.2, &mut v1470);
                                                let mut v1470 = v1470.into_context_iter();
                                                while let Some(v1471) = v1470.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v1621,
                                                        arg: v1622,
                                                    } = &v1471.1 {
                                                        if let &Opcode::Uextend = v1621 {
                                                            if v2.0 == v1471.0 {
                                                                let v1620 = C::value_type(ctx, v99);
                                                                let v1623 = C::value_type(ctx, v1622);
                                                                if v1620 == v1623 {
                                                                    let v1624 = constructor_select(ctx, v1620, v84.0, v99, v1622);
                                                                    let v1625 = constructor_uextend(ctx, v2.0, v1624);
                                                                    // Rule at src/opts/selects.isle line 80.
                                                                    returns.extend(Some(v1625));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Sextend => {
                                            if v2.0 == v95.0 {
                                                let mut v1470 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v84.2, &mut v1470);
                                                let mut v1470 = v1470.into_context_iter();
                                                while let Some(v1471) = v1470.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v1621,
                                                        arg: v1622,
                                                    } = &v1471.1 {
                                                        if let &Opcode::Sextend = v1621 {
                                                            if v2.0 == v1471.0 {
                                                                let v1620 = C::value_type(ctx, v99);
                                                                let v1623 = C::value_type(ctx, v1622);
                                                                if v1620 == v1623 {
                                                                    let v1624 = constructor_select(ctx, v1620, v84.0, v99, v1622);
                                                                    let v1626 = constructor_sextend(ctx, v2.0, v1624);
                                                                    // Rule at src/opts/selects.isle line 84.
                                                                    returns.extend(Some(v1626));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v1579,
                                    imm: v1580,
                                } => {
                                    if let &Opcode::Iconst = v1579 {
                                        let v1581 = C::u64_from_imm64(ctx, v1580);
                                        if v1581 == 0x1_u64 {
                                            if v2.0 == v95.0 {
                                                let mut v1470 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v84.2, &mut v1470);
                                                let mut v1470 = v1470.into_context_iter();
                                                while let Some(v1471) = v1470.next(ctx) {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v1705,
                                                        args: ref v1706,
                                                    } = &v1471.1 {
                                                        if let &Opcode::Bor = v1705 {
                                                            if v2.0 == v1471.0 {
                                                                let v1707 = C::unpack_value_array_2(ctx, v1706);
                                                                if v84.0 == v1707.0 {
                                                                    let v1324 = constructor_iconst_u(ctx, v2.0, 0x1_u64);
                                                                    let v1723 = constructor_select(ctx, v2.0, v84.0, v1324, v1707.1);
                                                                    // Rule at src/opts/selects.isle line 180.
                                                                    returns.extend(Some(v1723));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v84.0 == v1707.1 {
                                                                    let v1324 = constructor_iconst_u(ctx, v2.0, 0x1_u64);
                                                                    let v1724 = constructor_select(ctx, v2.0, v84.0, v1324, v1707.0);
                                                                    // Rule at src/opts/selects.isle line 181.
                                                                    returns.extend(Some(v1724));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                        if v84.1 == v84.2 {
                            let v1035 = C::subsume(ctx, v84.1);
                            // Rule at src/opts/selects.isle line 3.
                            returns.extend(Some(v1035));
                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                        }
                        let mut v331 = ContextIterWrapper::<ConstructorVec<_>, _>::default();
                        constructor_truthy(ctx, v84.0, &mut v331);
                        let mut v331 = v331.into_context_iter();
                        while let Some(v332) = v331.next(ctx) {
                            let v333 = constructor_select(ctx, v2.0, v332, v84.1, v84.2);
                            // Rule at src/opts/bitops.isle line 112.
                            returns.extend(Some(v333));
                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                        }
                        let mut v1470 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v84.2, &mut v1470);
                        let mut v1470 = v1470.into_context_iter();
                        while let Some(v1471) = v1470.next(ctx) {
                            if let &InstructionData::Ternary {
                                opcode: ref v1659,
                                args: ref v1660,
                            } = &v1471.1 {
                                if let &Opcode::Select = v1659 {
                                    if v2.0 == v1471.0 {
                                        let v1661 = C::unpack_value_array_3(ctx, v1660);
                                        if v84.0 == v1661.0 {
                                            let v1665 = constructor_select(ctx, v2.0, v84.0, v84.1, v1661.2);
                                            // Rule at src/opts/selects.isle line 101.
                                            returns.extend(Some(v1665));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    &Opcode::SelectSpectreGuard => {
                        let v84 = C::unpack_value_array_3(ctx, v83);
                        let mut v88 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v84.0, &mut v88);
                        let mut v88 = v88.into_context_iter();
                        while let Some(v89) = v88.next(ctx) {
                            if let &InstructionData::UnaryImm {
                                opcode: ref v1030,
                                imm: v1031,
                            } = &v89.1 {
                                if let &Opcode::Iconst = v1030 {
                                    let v1032 = C::u64_from_imm64(ctx, v1031);
                                    if v1032 == 0x0_u64 {
                                        let v1036 = C::subsume(ctx, v84.2);
                                        // Rule at src/opts/spectre.isle line 13.
                                        returns.extend(Some(v1036));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                    let v1033 = C::u64_matches_non_zero(ctx, v1032);
                                    if let Some(v1034) = v1033 {
                                        if v1034 == true {
                                            let v1035 = C::subsume(ctx, v84.1);
                                            // Rule at src/opts/spectre.isle line 11.
                                            returns.extend(Some(v1035));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                            }
                        }
                        if v84.1 == v84.2 {
                            let v1035 = C::subsume(ctx, v84.1);
                            // Rule at src/opts/spectre.isle line 9.
                            returns.extend(Some(v1035));
                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                        }
                    }
                    &Opcode::Bitselect => {
                        let v1608 = C::multi_lane(ctx, v2.0);
                        if let Some(v1609) = v1608 {
                            let v84 = C::unpack_value_array_3(ctx, v83);
                            let mut v88 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v84.0, &mut v88);
                            let mut v88 = v88.into_context_iter();
                            while let Some(v89) = v88.next(ctx) {
                                if let &InstructionData::IntCompare {
                                    opcode: ref v1454,
                                    args: ref v1455,
                                    cond: ref v1456,
                                } = &v89.1 {
                                    if let &Opcode::Icmp = v1454 {
                                        match v1456 {
                                            &IntCC::SignedGreaterThan => {
                                                let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                if v84.1 == v1457.0 {
                                                    if v84.2 == v1457.1 {
                                                        let v1604 = constructor_smax(ctx, v2.0, v1457.0, v1457.1);
                                                        // Rule at src/opts/selects.isle line 45.
                                                        returns.extend(Some(v1604));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v84.1 == v1457.1 {
                                                    if v84.2 == v1457.0 {
                                                        let v1606 = constructor_smin(ctx, v2.0, v1457.0, v1457.1);
                                                        // Rule at src/opts/selects.isle line 59.
                                                        returns.extend(Some(v1606));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::SignedGreaterThanOrEqual => {
                                                let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                if v84.1 == v1457.0 {
                                                    if v84.2 == v1457.1 {
                                                        let v1604 = constructor_smax(ctx, v2.0, v1457.0, v1457.1);
                                                        // Rule at src/opts/selects.isle line 46.
                                                        returns.extend(Some(v1604));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v84.1 == v1457.1 {
                                                    if v84.2 == v1457.0 {
                                                        let v1606 = constructor_smin(ctx, v2.0, v1457.0, v1457.1);
                                                        // Rule at src/opts/selects.isle line 60.
                                                        returns.extend(Some(v1606));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::SignedLessThan => {
                                                let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                if v84.1 == v1457.0 {
                                                    if v84.2 == v1457.1 {
                                                        let v1606 = constructor_smin(ctx, v2.0, v1457.0, v1457.1);
                                                        // Rule at src/opts/selects.isle line 49.
                                                        returns.extend(Some(v1606));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v84.1 == v1457.1 {
                                                    if v84.2 == v1457.0 {
                                                        let v1604 = constructor_smax(ctx, v2.0, v1457.0, v1457.1);
                                                        // Rule at src/opts/selects.isle line 55.
                                                        returns.extend(Some(v1604));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::SignedLessThanOrEqual => {
                                                let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                if v84.1 == v1457.0 {
                                                    if v84.2 == v1457.1 {
                                                        let v1606 = constructor_smin(ctx, v2.0, v1457.0, v1457.1);
                                                        // Rule at src/opts/selects.isle line 50.
                                                        returns.extend(Some(v1606));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v84.1 == v1457.1 {
                                                    if v84.2 == v1457.0 {
                                                        let v1604 = constructor_smax(ctx, v2.0, v1457.0, v1457.1);
                                                        // Rule at src/opts/selects.isle line 56.
                                                        returns.extend(Some(v1604));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::UnsignedGreaterThan => {
                                                let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                if v84.1 == v1457.0 {
                                                    if v84.2 == v1457.1 {
                                                        let v1605 = constructor_umax(ctx, v2.0, v1457.0, v1457.1);
                                                        // Rule at src/opts/selects.isle line 47.
                                                        returns.extend(Some(v1605));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v84.1 == v1457.1 {
                                                    if v84.2 == v1457.0 {
                                                        let v1607 = constructor_umin(ctx, v2.0, v1457.0, v1457.1);
                                                        // Rule at src/opts/selects.isle line 61.
                                                        returns.extend(Some(v1607));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::UnsignedGreaterThanOrEqual => {
                                                let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                if v84.1 == v1457.0 {
                                                    if v84.2 == v1457.1 {
                                                        let v1605 = constructor_umax(ctx, v2.0, v1457.0, v1457.1);
                                                        // Rule at src/opts/selects.isle line 48.
                                                        returns.extend(Some(v1605));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v84.1 == v1457.1 {
                                                    if v84.2 == v1457.0 {
                                                        let v1607 = constructor_umin(ctx, v2.0, v1457.0, v1457.1);
                                                        // Rule at src/opts/selects.isle line 62.
                                                        returns.extend(Some(v1607));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::UnsignedLessThan => {
                                                let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                if v84.1 == v1457.0 {
                                                    if v84.2 == v1457.1 {
                                                        let v1607 = constructor_umin(ctx, v2.0, v1457.0, v1457.1);
                                                        // Rule at src/opts/selects.isle line 51.
                                                        returns.extend(Some(v1607));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v84.1 == v1457.1 {
                                                    if v84.2 == v1457.0 {
                                                        let v1605 = constructor_umax(ctx, v2.0, v1457.0, v1457.1);
                                                        // Rule at src/opts/selects.isle line 57.
                                                        returns.extend(Some(v1605));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::UnsignedLessThanOrEqual => {
                                                let v1457 = C::unpack_value_array_2(ctx, v1455);
                                                if v84.1 == v1457.0 {
                                                    if v84.2 == v1457.1 {
                                                        let v1607 = constructor_umin(ctx, v2.0, v1457.0, v1457.1);
                                                        // Rule at src/opts/selects.isle line 52.
                                                        returns.extend(Some(v1607));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v84.1 == v1457.1 {
                                                    if v84.2 == v1457.0 {
                                                        let v1605 = constructor_umax(ctx, v2.0, v1457.0, v1457.1);
                                                        // Rule at src/opts/selects.isle line 58.
                                                        returns.extend(Some(v1605));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                }
                            }
                        }
                        let v84 = C::unpack_value_array_3(ctx, v83);
                        if v84.1 == v84.2 {
                            let v1035 = C::subsume(ctx, v84.1);
                            // Rule at src/opts/selects.isle line 4.
                            returns.extend(Some(v1035));
                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                        }
                    }
                    &Opcode::Fma => {
                        let v84 = C::unpack_value_array_3(ctx, v83);
                        let mut v88 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v84.0, &mut v88);
                        let mut v88 = v88.into_context_iter();
                        while let Some(v89) = v88.next(ctx) {
                            if let &InstructionData::Unary {
                                opcode: ref v92,
                                arg: v93,
                            } = &v89.1 {
                                if let &Opcode::Fneg = v92 {
                                    if v2.0 == v89.0 {
                                        let mut v94 = C::inst_data_value_etor_returns::default();
                                        C::inst_data_value_etor(ctx, v84.1, &mut v94);
                                        let mut v94 = v94.into_context_iter();
                                        while let Some(v95) = v94.next(ctx) {
                                            if let &InstructionData::Unary {
                                                opcode: ref v98,
                                                arg: v99,
                                            } = &v95.1 {
                                                if let &Opcode::Fneg = v98 {
                                                    if v2.0 == v95.0 {
                                                        let v100 = constructor_fma(ctx, v2.0, v93, v99, v84.2);
                                                        // Rule at src/opts/arithmetic.isle line 190.
                                                        returns.extend(Some(v100));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    _ => {}
                }
            }
            &InstructionData::Unary {
                opcode: ref v32,
                arg: v33,
            } => {
                match v32 {
                    &Opcode::Splat => {
                        let v1063 = C::ty_vec128(ctx, v2.0);
                        if let Some(v1064) = v1063 {
                            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 v1080,
                                        imm: v1081,
                                    } => {
                                        if let &Opcode::F32const = v1080 {
                                            let v1082 = C::u32_from_ieee32(ctx, v1081);
                                            let v1083 = C::u32_into_u64(ctx, v1082);
                                            let v1084 = constructor_splat32(ctx, v1083);
                                            let v1085 = constructor_vconst(ctx, v1064, v1084);
                                            // Rule at src/opts/cprop.isle line 283.
                                            returns.extend(Some(v1085));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                    &InstructionData::UnaryIeee64 {
                                        opcode: ref v1086,
                                        imm: v1087,
                                    } => {
                                        if let &Opcode::F64const = v1086 {
                                            let v1088 = C::u64_from_ieee64(ctx, v1087);
                                            let v1089 = C::splat64(ctx, v1088);
                                            let v1090 = constructor_vconst(ctx, v1064, v1089);
                                            // Rule at src/opts/cprop.isle line 285.
                                            returns.extend(Some(v1090));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                    &InstructionData::UnaryImm {
                                        opcode: ref v917,
                                        imm: v918,
                                    } => {
                                        if let &Opcode::Iconst = v917 {
                                            match v35.0 {
                                                I8 => {
                                                    let v1065 = C::u64_uextend_imm64(ctx, I8, v918);
                                                    let v1066 = constructor_splat8(ctx, v1065);
                                                    let v1067 = constructor_vconst(ctx, v1064, v1066);
                                                    // Rule at src/opts/cprop.isle line 275.
                                                    returns.extend(Some(v1067));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                I16 => {
                                                    let v1069 = C::u64_uextend_imm64(ctx, I16, v918);
                                                    let v1070 = constructor_splat16(ctx, v1069);
                                                    let v1071 = constructor_vconst(ctx, v1064, v1070);
                                                    // Rule at src/opts/cprop.isle line 277.
                                                    returns.extend(Some(v1071));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                I32 => {
                                                    let v1073 = C::u64_uextend_imm64(ctx, I32, v918);
                                                    let v1074 = constructor_splat32(ctx, v1073);
                                                    let v1075 = constructor_vconst(ctx, v1064, v1074);
                                                    // Rule at src/opts/cprop.isle line 279.
                                                    returns.extend(Some(v1075));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                I64 => {
                                                    let v1077 = C::u64_uextend_imm64(ctx, I64, v918);
                                                    let v1078 = C::splat64(ctx, v1077);
                                                    let v1079 = constructor_vconst(ctx, v1064, v1078);
                                                    // Rule at src/opts/cprop.isle line 281.
                                                    returns.extend(Some(v1079));
                                                    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::Imul => {
                                            if v2.0 == v35.0 {
                                                let v40 = C::unpack_value_array_2(ctx, v39);
                                                let mut v261 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v40.0, &mut v261);
                                                let mut v261 = v261.into_context_iter();
                                                while let Some(v262) = v261.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v265,
                                                        arg: v266,
                                                    } = &v262.1 {
                                                        if let &Opcode::Ineg = v265 {
                                                            if v2.0 == v262.0 {
                                                                let v267 = constructor_imul(ctx, v2.0, v40.1, v266);
                                                                // Rule at src/opts/arithmetic.isle line 337.
                                                                returns.extend(Some(v267));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                                let mut v268 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v40.1, &mut v268);
                                                let mut v268 = v268.into_context_iter();
                                                while let Some(v269) = v268.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v272,
                                                        arg: v273,
                                                    } = &v269.1 {
                                                        if let &Opcode::Ineg = v272 {
                                                            if v2.0 == v269.0 {
                                                                let v274 = constructor_imul(ctx, v2.0, v40.0, v273);
                                                                // Rule at src/opts/arithmetic.isle line 338.
                                                                returns.extend(Some(v274));
                                                                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 v268 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v40.1, &mut v268);
                                                let mut v268 = v268.into_context_iter();
                                                while let Some(v269) = v268.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v1307,
                                                        imm: v1308,
                                                    } = &v269.1 {
                                                        if let &Opcode::Iconst = v1307 {
                                                            let v1798 = C::u64_from_imm64(ctx, v1308);
                                                            let v316 = constructor_ty_shift_mask(ctx, v2.0);
                                                            let v1799 = C::u64_eq(ctx, v1798, v316);
                                                            if v1799 == true {
                                                                if v2.0 == v269.0 {
                                                                    let v1800 = constructor_sshr(ctx, v2.0, v40.0, v40.1);
                                                                    // Rule at src/opts/shifts.isle line 98.
                                                                    returns.extend(Some(v1800));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v45,
                                    arg: v46,
                                } => {
                                    match v45 {
                                        &Opcode::Splat => {
                                            if v2.0 == v35.0 {
                                                let v1816 = C::lane_type(ctx, v2.0);
                                                let v1973 = constructor_ineg(ctx, v1816, v46);
                                                let v1974 = constructor_splat(ctx, v2.0, v1973);
                                                // Rule at src/opts/vector.isle line 45.
                                                returns.extend(Some(v1974));
                                                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 v1816 = C::lane_type(ctx, v2.0);
                                            let v1975 = constructor_iabs(ctx, v1816, v46);
                                            let v1976 = constructor_splat(ctx, v2.0, v1975);
                                            // Rule at src/opts/vector.isle line 48.
                                            returns.extend(Some(v1976));
                                            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 v64 = C::inst_data_value_tupled_etor_returns::default();
                                                C::inst_data_value_tupled_etor(ctx, v40.1, &mut v64);
                                                let mut v64 = v64.into_context_iter();
                                                while let Some(v65) = v64.next(ctx) {
                                                    let v66 = C::iconst_sextend_etor(ctx, v65);
                                                    if let Some(v67) = v66 {
                                                        if v67.1 == -1_i64 {
                                                            if v2.0 == v67.0 {
                                                                let v70 = constructor_ineg(ctx, v2.0, v40.0);
                                                                // Rule at src/opts/arithmetic.isle line 74.
                                                                returns.extend(Some(v70));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                                let mut v261 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v40.0, &mut v261);
                                                let mut v261 = v261.into_context_iter();
                                                while let Some(v262) = v261.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v265,
                                                        arg: v266,
                                                    } = &v262.1 {
                                                        if let &Opcode::Bnot = v265 {
                                                            if v2.0 == v262.0 {
                                                                let v773 = constructor_isub(ctx, v2.0, v266, v40.1);
                                                                // Rule at src/opts/bitops.isle line 410.
                                                                returns.extend(Some(v773));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                                let mut v268 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v40.1, &mut v268);
                                                let mut v268 = v268.into_context_iter();
                                                while let Some(v269) = v268.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v272,
                                                        arg: v273,
                                                    } = &v269.1 {
                                                        if let &Opcode::Bnot = v272 {
                                                            if v2.0 == v269.0 {
                                                                let v774 = constructor_isub(ctx, v2.0, v273, v40.0);
                                                                // Rule at src/opts/bitops.isle line 411.
                                                                returns.extend(Some(v774));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            let v292 = C::fits_in_64(ctx, v2.0);
                                            if let Some(v293) = v292 {
                                                if v35.0 == v293 {
                                                    let v40 = C::unpack_value_array_2(ctx, v39);
                                                    let mut v268 = C::inst_data_value_etor_returns::default();
                                                    C::inst_data_value_etor(ctx, v40.1, &mut v268);
                                                    let mut v268 = v268.into_context_iter();
                                                    while let Some(v269) = v268.next(ctx) {
                                                        if let &InstructionData::UnaryImm {
                                                            opcode: ref v1307,
                                                            imm: v1308,
                                                        } = &v269.1 {
                                                            if let &Opcode::Iconst = v1307 {
                                                                if v35.0 == v269.0 {
                                                                    let v1309 = constructor_bnot(ctx, v293, v40.0);
                                                                    let v1310 = C::imm64_neg(ctx, v293, v1308);
                                                                    let v1311 = constructor_iconst(ctx, v293, v1310);
                                                                    let v1312 = constructor_iadd(ctx, v293, v1309, v1311);
                                                                    // Rule at src/opts/cprop.isle line 501.
                                                                    returns.extend(Some(v1312));
                                                                    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 v64 = C::inst_data_value_tupled_etor_returns::default();
                                                C::inst_data_value_tupled_etor(ctx, v40.1, &mut v64);
                                                let mut v64 = v64.into_context_iter();
                                                while let Some(v65) = v64.next(ctx) {
                                                    let v66 = C::iconst_sextend_etor(ctx, v65);
                                                    if let Some(v67) = v66 {
                                                        if v67.1 == 1_i64 {
                                                            if v2.0 == v67.0 {
                                                                let v70 = constructor_ineg(ctx, v2.0, v40.0);
                                                                // Rule at src/opts/arithmetic.isle line 72.
                                                                returns.extend(Some(v70));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Band => {
                                            if v2.0 == v35.0 {
                                                let v40 = C::unpack_value_array_2(ctx, v39);
                                                let mut v261 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v40.0, &mut v261);
                                                let mut v261 = v261.into_context_iter();
                                                while let Some(v262) = v261.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v265,
                                                        arg: v266,
                                                    } = &v262.1 {
                                                        if let &Opcode::Bnot = v265 {
                                                            if v2.0 == v262.0 {
                                                                let v750 = constructor_bnot(ctx, v2.0, v40.1);
                                                                let v751 = constructor_bor(ctx, v2.0, v266, v750);
                                                                // Rule at src/opts/bitops.isle line 351.
                                                                returns.extend(Some(v751));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                                let mut v268 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v40.1, &mut v268);
                                                let mut v268 = v268.into_context_iter();
                                                while let Some(v269) = v268.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v272,
                                                        arg: v273,
                                                    } = &v269.1 {
                                                        if let &Opcode::Bnot = v272 {
                                                            if v2.0 == v269.0 {
                                                                let v752 = constructor_bnot(ctx, v2.0, v40.0);
                                                                let v753 = constructor_bor(ctx, v2.0, v273, v752);
                                                                // Rule at src/opts/bitops.isle line 352.
                                                                returns.extend(Some(v753));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Bor => {
                                            if v2.0 == v35.0 {
                                                let v40 = C::unpack_value_array_2(ctx, v39);
                                                let mut v261 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v40.0, &mut v261);
                                                let mut v261 = v261.into_context_iter();
                                                while let Some(v262) = v261.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v265,
                                                        arg: v266,
                                                    } = &v262.1 {
                                                        if let &Opcode::Bnot = v265 {
                                                            if v2.0 == v262.0 {
                                                                let v750 = constructor_bnot(ctx, v2.0, v40.1);
                                                                let v754 = constructor_band(ctx, v2.0, v266, v750);
                                                                // Rule at src/opts/bitops.isle line 355.
                                                                returns.extend(Some(v754));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                                let mut v268 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v40.1, &mut v268);
                                                let mut v268 = v268.into_context_iter();
                                                while let Some(v269) = v268.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v272,
                                                        arg: v273,
                                                    } = &v269.1 {
                                                        if let &Opcode::Bnot = v272 {
                                                            if v2.0 == v269.0 {
                                                                let v752 = constructor_bnot(ctx, v2.0, v40.0);
                                                                let v755 = constructor_band(ctx, v2.0, v273, v752);
                                                                // Rule at src/opts/bitops.isle line 356.
                                                                returns.extend(Some(v755));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v45,
                                    arg: v46,
                                } => {
                                    match v45 {
                                        &Opcode::Splat => {
                                            let v1953 = C::ty_vector_not_float(ctx, v2.0);
                                            if let Some(v1954) = v1953 {
                                                if v2.0 == v35.0 {
                                                    let v1816 = C::lane_type(ctx, v2.0);
                                                    let v1961 = constructor_bnot(ctx, v1816, v46);
                                                    let v1962 = constructor_splat(ctx, v2.0, v1961);
                                                    // Rule at src/opts/vector.isle line 26.
                                                    returns.extend(Some(v1962));
                                                    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 v917,
                                    imm: v918,
                                } => {
                                    if let &Opcode::Iconst = v917 {
                                        let v292 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v293) = v292 {
                                            if v35.0 == v293 {
                                                let v943 = C::imm64_not(ctx, v293, v918);
                                                let v944 = constructor_iconst(ctx, v293, v943);
                                                let v945 = C::subsume(ctx, v944);
                                                // Rule at src/opts/cprop.isle line 73.
                                                returns.extend(Some(v945));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                        let v1572 = C::remat(ctx, arg0);
                        // Rule at src/opts/remat.isle line 23.
                        returns.extend(Some(v1572));
                        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 v292 = C::fits_in_64(ctx, v2.0);
                        if let Some(v293) = v292 {
                            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 v917,
                                    imm: v918,
                                } = &v35.1 {
                                    if let &Opcode::Iconst = v917 {
                                        if v35.0 == v293 {
                                            let v919 = C::imm64_clz(ctx, v293, v918);
                                            let v920 = constructor_iconst(ctx, v293, v919);
                                            let v921 = C::subsume(ctx, v920);
                                            // Rule at src/opts/cprop.isle line 2.
                                            returns.extend(Some(v921));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    &Opcode::Ctz => {
                        let v292 = C::fits_in_64(ctx, v2.0);
                        if let Some(v293) = v292 {
                            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 v917,
                                    imm: v918,
                                } = &v35.1 {
                                    if let &Opcode::Iconst = v917 {
                                        if v35.0 == v293 {
                                            let v922 = C::imm64_ctz(ctx, v293, v918);
                                            let v923 = constructor_iconst(ctx, v293, v922);
                                            let v924 = C::subsume(ctx, v923);
                                            // Rule at src/opts/cprop.isle line 8.
                                            returns.extend(Some(v924));
                                            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 v917,
                                    imm: v918,
                                } => {
                                    if let &Opcode::Iconst = v917 {
                                        match v2.0 {
                                            I16 => {
                                                let v975 = C::u64_from_imm64(ctx, v918);
                                                let v1122 = C::u64_bswap16(ctx, v975);
                                                let v1123 = C::imm64(ctx, v1122);
                                                let v1124 = constructor_iconst(ctx, I16, v1123);
                                                let v1125 = C::subsume(ctx, v1124);
                                                // Rule at src/opts/cprop.isle line 355.
                                                returns.extend(Some(v1125));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            I32 => {
                                                let v975 = C::u64_from_imm64(ctx, v918);
                                                let v1126 = C::u64_bswap32(ctx, v975);
                                                let v1127 = C::imm64(ctx, v1126);
                                                let v1128 = constructor_iconst(ctx, I32, v1127);
                                                let v1129 = C::subsume(ctx, v1128);
                                                // Rule at src/opts/cprop.isle line 357.
                                                returns.extend(Some(v1129));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            I64 => {
                                                let v975 = C::u64_from_imm64(ctx, v918);
                                                let v1130 = C::u64_bswap64(ctx, v975);
                                                let v1131 = C::imm64(ctx, v1130);
                                                let v1132 = constructor_iconst(ctx, I64, v1131);
                                                let v1133 = C::subsume(ctx, v1132);
                                                // Rule at src/opts/cprop.isle line 359.
                                                returns.extend(Some(v1133));
                                                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 v1816 = C::lane_type(ctx, v2.0);
                                        let v1977 = constructor_popcnt(ctx, v1816, v46);
                                        let v1978 = constructor_splat(ctx, v2.0, v1977);
                                        // Rule at src/opts/vector.isle line 51.
                                        returns.extend(Some(v1978));
                                        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 v1080,
                                            imm: v1081,
                                        } = &v35.1 {
                                            if let &Opcode::F32const = v1080 {
                                                let v1174 = C::f32_sqrt(ctx, v1081);
                                                if let Some(v1175) = v1174 {
                                                    let v1176 = constructor_f32const(ctx, F32, v1175);
                                                    let v1177 = C::subsume(ctx, v1176);
                                                    // Rule at src/opts/cprop.isle line 406.
                                                    returns.extend(Some(v1177));
                                                    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 v1086,
                                            imm: v1087,
                                        } = &v35.1 {
                                            if let &Opcode::F64const = v1086 {
                                                let v1178 = C::f64_sqrt(ctx, v1087);
                                                if let Some(v1179) = v1178 {
                                                    let v1180 = constructor_f64const(ctx, F64, v1179);
                                                    let v1181 = C::subsume(ctx, v1180);
                                                    // Rule at src/opts/cprop.isle line 409.
                                                    returns.extend(Some(v1181));
                                                    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 v1273,
                                    constant_handle: v1274,
                                } => {
                                    if let &Opcode::F128const = v1273 {
                                        if v2.0 == F128 {
                                            if v35.0 == F128 {
                                                let v1275 = C::ieee128_constant_extractor(ctx, v1274);
                                                if let Some(v1276) = v1275 {
                                                    let v1277 = C::f128_neg(ctx, v1276);
                                                    let v1278 = C::ieee128_constant(ctx, v1277);
                                                    let v1279 = constructor_f128const(ctx, F128, v1278);
                                                    let v1280 = C::subsume(ctx, v1279);
                                                    // Rule at src/opts/cprop.isle line 473.
                                                    returns.extend(Some(v1280));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryIeee16 {
                                    opcode: ref v1262,
                                    imm: v1263,
                                } => {
                                    if let &Opcode::F16const = v1262 {
                                        if v2.0 == F16 {
                                            if v35.0 == F16 {
                                                let v1264 = C::f16_neg(ctx, v1263);
                                                let v1265 = constructor_f16const(ctx, F16, v1264);
                                                let v1266 = C::subsume(ctx, v1265);
                                                // Rule at src/opts/cprop.isle line 467.
                                                returns.extend(Some(v1266));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryIeee32 {
                                    opcode: ref v1080,
                                    imm: v1081,
                                } => {
                                    if let &Opcode::F32const = v1080 {
                                        if v2.0 == F32 {
                                            if v35.0 == F32 {
                                                let v1267 = C::f32_neg(ctx, v1081);
                                                let v1268 = constructor_f32const(ctx, F32, v1267);
                                                let v1269 = C::subsume(ctx, v1268);
                                                // Rule at src/opts/cprop.isle line 469.
                                                returns.extend(Some(v1269));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryIeee64 {
                                    opcode: ref v1086,
                                    imm: v1087,
                                } => {
                                    if let &Opcode::F64const = v1086 {
                                        if v2.0 == F64 {
                                            if v35.0 == F64 {
                                                let v1270 = C::f64_neg(ctx, v1087);
                                                let v1271 = constructor_f64const(ctx, F64, v1270);
                                                let v1272 = C::subsume(ctx, v1271);
                                                // Rule at src/opts/cprop.isle line 471.
                                                returns.extend(Some(v1272));
                                                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 v1262,
                                            imm: v1263,
                                        } = &v35.1 {
                                            if let &Opcode::F16const = v1262 {
                                                let v1281 = C::f16_abs(ctx, v1263);
                                                let v1282 = constructor_f16const(ctx, F16, v1281);
                                                let v1283 = C::subsume(ctx, v1282);
                                                // Rule at src/opts/cprop.isle line 476.
                                                returns.extend(Some(v1283));
                                                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 v1080,
                                            imm: v1081,
                                        } = &v35.1 {
                                            if let &Opcode::F32const = v1080 {
                                                let v1284 = C::f32_abs(ctx, v1081);
                                                let v1285 = constructor_f32const(ctx, F32, v1284);
                                                let v1286 = C::subsume(ctx, v1285);
                                                // Rule at src/opts/cprop.isle line 478.
                                                returns.extend(Some(v1286));
                                                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 v1086,
                                            imm: v1087,
                                        } = &v35.1 {
                                            if let &Opcode::F64const = v1086 {
                                                let v1287 = C::f64_abs(ctx, v1087);
                                                let v1288 = constructor_f64const(ctx, F64, v1287);
                                                let v1289 = C::subsume(ctx, v1288);
                                                // Rule at src/opts/cprop.isle line 480.
                                                returns.extend(Some(v1289));
                                                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 v1273,
                                            constant_handle: v1274,
                                        } = &v35.1 {
                                            if let &Opcode::F128const = v1273 {
                                                let v1275 = C::ieee128_constant_extractor(ctx, v1274);
                                                if let Some(v1276) = v1275 {
                                                    let v1290 = C::f128_abs(ctx, v1276);
                                                    let v1291 = C::ieee128_constant(ctx, v1290);
                                                    let v1292 = constructor_f128const(ctx, F128, v1291);
                                                    let v1293 = C::subsume(ctx, v1292);
                                                    // Rule at src/opts/cprop.isle line 482.
                                                    returns.extend(Some(v1293));
                                                    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 v1080,
                                            imm: v1081,
                                        } = &v35.1 {
                                            if let &Opcode::F32const = v1080 {
                                                let v1182 = C::f32_ceil(ctx, v1081);
                                                if let Some(v1183) = v1182 {
                                                    let v1184 = constructor_f32const(ctx, F32, v1183);
                                                    let v1185 = C::subsume(ctx, v1184);
                                                    // Rule at src/opts/cprop.isle line 413.
                                                    returns.extend(Some(v1185));
                                                    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 v1086,
                                            imm: v1087,
                                        } = &v35.1 {
                                            if let &Opcode::F64const = v1086 {
                                                let v1186 = C::f64_ceil(ctx, v1087);
                                                if let Some(v1187) = v1186 {
                                                    let v1188 = constructor_f64const(ctx, F64, v1187);
                                                    let v1189 = C::subsume(ctx, v1188);
                                                    // Rule at src/opts/cprop.isle line 416.
                                                    returns.extend(Some(v1189));
                                                    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 v1080,
                                            imm: v1081,
                                        } = &v35.1 {
                                            if let &Opcode::F32const = v1080 {
                                                let v1190 = C::f32_floor(ctx, v1081);
                                                if let Some(v1191) = v1190 {
                                                    let v1192 = constructor_f32const(ctx, F32, v1191);
                                                    let v1193 = C::subsume(ctx, v1192);
                                                    // Rule at src/opts/cprop.isle line 420.
                                                    returns.extend(Some(v1193));
                                                    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 v1086,
                                            imm: v1087,
                                        } = &v35.1 {
                                            if let &Opcode::F64const = v1086 {
                                                let v1194 = C::f64_floor(ctx, v1087);
                                                if let Some(v1195) = v1194 {
                                                    let v1196 = constructor_f64const(ctx, F64, v1195);
                                                    let v1197 = C::subsume(ctx, v1196);
                                                    // Rule at src/opts/cprop.isle line 423.
                                                    returns.extend(Some(v1197));
                                                    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 v1080,
                                            imm: v1081,
                                        } = &v35.1 {
                                            if let &Opcode::F32const = v1080 {
                                                let v1198 = C::f32_trunc(ctx, v1081);
                                                if let Some(v1199) = v1198 {
                                                    let v1200 = constructor_f32const(ctx, F32, v1199);
                                                    let v1201 = C::subsume(ctx, v1200);
                                                    // Rule at src/opts/cprop.isle line 427.
                                                    returns.extend(Some(v1201));
                                                    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 v1086,
                                            imm: v1087,
                                        } = &v35.1 {
                                            if let &Opcode::F64const = v1086 {
                                                let v1202 = C::f64_trunc(ctx, v1087);
                                                if let Some(v1203) = v1202 {
                                                    let v1204 = constructor_f64const(ctx, F64, v1203);
                                                    let v1205 = C::subsume(ctx, v1204);
                                                    // Rule at src/opts/cprop.isle line 430.
                                                    returns.extend(Some(v1205));
                                                    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 v1080,
                                            imm: v1081,
                                        } = &v35.1 {
                                            if let &Opcode::F32const = v1080 {
                                                let v1206 = C::f32_nearest(ctx, v1081);
                                                if let Some(v1207) = v1206 {
                                                    let v1208 = constructor_f32const(ctx, F32, v1207);
                                                    let v1209 = C::subsume(ctx, v1208);
                                                    // Rule at src/opts/cprop.isle line 434.
                                                    returns.extend(Some(v1209));
                                                    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 v1086,
                                            imm: v1087,
                                        } = &v35.1 {
                                            if let &Opcode::F64const = v1086 {
                                                let v1210 = C::f64_nearest(ctx, v1087);
                                                if let Some(v1211) = v1210 {
                                                    let v1212 = constructor_f64const(ctx, F64, v1211);
                                                    let v1213 = C::subsume(ctx, v1212);
                                                    // Rule at src/opts/cprop.isle line 437.
                                                    returns.extend(Some(v1213));
                                                    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 v320,
                                        args: ref v321,
                                        cond: ref v322,
                                    } = &v35.1 {
                                        if let &Opcode::Icmp = v320 {
                                            let v327 = constructor_ineg(ctx, I8, v33);
                                            // Rule at src/opts/bitops.isle line 89.
                                            returns.extend(Some(v327));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                            }
                        }
                        let mut v328 = ContextIterWrapper::<ConstructorVec<_>, _>::default();
                        constructor_truthy(ctx, v33, &mut v328);
                        let mut v328 = v328.into_context_iter();
                        while let Some(v329) = v328.next(ctx) {
                            let v330 = constructor_bmask(ctx, v2.0, v329);
                            // Rule at src/opts/bitops.isle line 111.
                            returns.extend(Some(v330));
                            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 v1357 = constructor_ireduce(ctx, v2.0, v40.0);
                                            let v1358 = constructor_ireduce(ctx, v2.0, v40.1);
                                            let v1359 = constructor_iadd(ctx, v2.0, v1357, v1358);
                                            // Rule at src/opts/extends.isle line 85.
                                            returns.extend(Some(v1359));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Isub => {
                                            let v40 = C::unpack_value_array_2(ctx, v39);
                                            let v1357 = constructor_ireduce(ctx, v2.0, v40.0);
                                            let v1358 = constructor_ireduce(ctx, v2.0, v40.1);
                                            let v1360 = constructor_isub(ctx, v2.0, v1357, v1358);
                                            // Rule at src/opts/extends.isle line 86.
                                            returns.extend(Some(v1360));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Imul => {
                                            let v40 = C::unpack_value_array_2(ctx, v39);
                                            let v1357 = constructor_ireduce(ctx, v2.0, v40.0);
                                            let v1358 = constructor_ireduce(ctx, v2.0, v40.1);
                                            let v1361 = constructor_imul(ctx, v2.0, v1357, v1358);
                                            // Rule at src/opts/extends.isle line 87.
                                            returns.extend(Some(v1361));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Band => {
                                            let v40 = C::unpack_value_array_2(ctx, v39);
                                            let v1357 = constructor_ireduce(ctx, v2.0, v40.0);
                                            let v1358 = constructor_ireduce(ctx, v2.0, v40.1);
                                            let v1364 = constructor_band(ctx, v2.0, v1357, v1358);
                                            // Rule at src/opts/extends.isle line 90.
                                            returns.extend(Some(v1364));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Bor => {
                                            let v40 = C::unpack_value_array_2(ctx, v39);
                                            let v1357 = constructor_ireduce(ctx, v2.0, v40.0);
                                            let v1358 = constructor_ireduce(ctx, v2.0, v40.1);
                                            let v1362 = constructor_bor(ctx, v2.0, v1357, v1358);
                                            // Rule at src/opts/extends.isle line 88.
                                            returns.extend(Some(v1362));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Bxor => {
                                            let v40 = C::unpack_value_array_2(ctx, v39);
                                            let v1357 = constructor_ireduce(ctx, v2.0, v40.0);
                                            let v1358 = constructor_ireduce(ctx, v2.0, v40.1);
                                            let v1363 = constructor_bxor(ctx, v2.0, v1357, v1358);
                                            // Rule at src/opts/extends.isle line 89.
                                            returns.extend(Some(v1363));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v45,
                                    arg: v46,
                                } => {
                                    match v45 {
                                        &Opcode::Ineg => {
                                            let v1354 = constructor_ireduce(ctx, v2.0, v46);
                                            let v1355 = constructor_ineg(ctx, v2.0, v1354);
                                            // Rule at src/opts/extends.isle line 82.
                                            returns.extend(Some(v1355));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Bnot => {
                                            let v1354 = constructor_ireduce(ctx, v2.0, v46);
                                            let v1356 = constructor_bnot(ctx, v2.0, v1354);
                                            // Rule at src/opts/extends.isle line 83.
                                            returns.extend(Some(v1356));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Bmask => {
                                            let v341 = constructor_bmask(ctx, v2.0, v46);
                                            // Rule at src/opts/bitops.isle line 125.
                                            returns.extend(Some(v341));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Uextend => {
                                            let v297 = C::ty_int(ctx, v2.0);
                                            if let Some(v298) = v297 {
                                                let v1340 = C::ty_bits_u64(ctx, v298);
                                                let v1339 = C::value_type(ctx, v46);
                                                let v1341 = C::ty_bits_u64(ctx, v1339);
                                                let v1342 = C::u64_lt(ctx, v1340, v1341);
                                                if v1342 == true {
                                                    let v1343 = constructor_ireduce(ctx, v298, v46);
                                                    // Rule at src/opts/extends.isle line 57.
                                                    returns.extend(Some(v1343));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let v1344 = C::u64_lt(ctx, v1341, v1340);
                                                if v1344 == true {
                                                    let v1346 = constructor_uextend(ctx, v298, v46);
                                                    // Rule at src/opts/extends.isle line 64.
                                                    returns.extend(Some(v1346));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                            let v1339 = C::value_type(ctx, v46);
                                            if v2.0 == v1339 {
                                                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 v297 = C::ty_int(ctx, v2.0);
                                            if let Some(v298) = v297 {
                                                let v1340 = C::ty_bits_u64(ctx, v298);
                                                let v1339 = C::value_type(ctx, v46);
                                                let v1341 = C::ty_bits_u64(ctx, v1339);
                                                let v1342 = C::u64_lt(ctx, v1340, v1341);
                                                if v1342 == true {
                                                    let v1343 = constructor_ireduce(ctx, v298, v46);
                                                    // Rule at src/opts/extends.isle line 54.
                                                    returns.extend(Some(v1343));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let v1344 = C::u64_lt(ctx, v1341, v1340);
                                                if v1344 == true {
                                                    let v1345 = constructor_sextend(ctx, v298, v46);
                                                    // Rule at src/opts/extends.isle line 61.
                                                    returns.extend(Some(v1345));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                            let v1339 = C::value_type(ctx, v46);
                                            if v2.0 == v1339 {
                                                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 v917,
                                    imm: v918,
                                } => {
                                    if let &Opcode::Iconst = v917 {
                                        let v973 = C::fits_in_64(ctx, v35.0);
                                        if let Some(v974) = v973 {
                                            let v975 = C::u64_from_imm64(ctx, v918);
                                            let v976 = C::imm64_masked(ctx, v2.0, v975);
                                            let v977 = constructor_iconst(ctx, v2.0, v976);
                                            let v978 = C::subsume(ctx, v977);
                                            // Rule at src/opts/cprop.isle line 124.
                                            returns.extend(Some(v978));
                                            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 v1816 = C::lane_type(ctx, v2.0);
                                    let v1997 = constructor_sextend(ctx, v1816, v46);
                                    let v1998 = constructor_splat(ctx, v2.0, v1997);
                                    // Rule at src/opts/vector.isle line 85.
                                    returns.extend(Some(v1998));
                                    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 v1816 = C::lane_type(ctx, v2.0);
                                    let v1997 = constructor_sextend(ctx, v1816, v46);
                                    let v1998 = constructor_splat(ctx, v2.0, v1997);
                                    // Rule at src/opts/vector.isle line 84.
                                    returns.extend(Some(v1998));
                                    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 v1816 = C::lane_type(ctx, v2.0);
                                    let v1999 = constructor_uextend(ctx, v1816, v46);
                                    let v2000 = constructor_splat(ctx, v2.0, v1999);
                                    // Rule at src/opts/vector.isle line 88.
                                    returns.extend(Some(v2000));
                                    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 v1816 = C::lane_type(ctx, v2.0);
                                    let v1999 = constructor_uextend(ctx, v1816, v46);
                                    let v2000 = constructor_splat(ctx, v2.0, v1999);
                                    // Rule at src/opts/vector.isle line 87.
                                    returns.extend(Some(v2000));
                                    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 v1313 = constructor_uextend(ctx, v2.0, v46);
                                        // Rule at src/opts/extends.isle line 1.
                                        returns.extend(Some(v1313));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v917,
                                    imm: v918,
                                } => {
                                    if let &Opcode::Iconst = v917 {
                                        let v292 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v293) = v292 {
                                            let v975 = C::u64_from_imm64(ctx, v918);
                                            let v979 = constructor_iconst_u(ctx, v293, v975);
                                            let v980 = C::subsume(ctx, v979);
                                            // Rule at src/opts/cprop.isle line 129.
                                            returns.extend(Some(v980));
                                            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 v320,
                                    args: ref v321,
                                    cond: ref v322,
                                } => {
                                    if let &Opcode::Icmp = v320 {
                                        let v1315 = constructor_uextend(ctx, v2.0, v33);
                                        // Rule at src/opts/extends.isle line 11.
                                        returns.extend(Some(v1315));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v45,
                                    arg: v46,
                                } => {
                                    match v45 {
                                        &Opcode::Bmask => {
                                            let v341 = constructor_bmask(ctx, v2.0, v46);
                                            // Rule at src/opts/bitops.isle line 124.
                                            returns.extend(Some(v341));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Uextend => {
                                            let v1313 = constructor_uextend(ctx, v2.0, v46);
                                            // Rule at src/opts/extends.isle line 7.
                                            returns.extend(Some(v1313));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Sextend => {
                                            let v1314 = constructor_sextend(ctx, v2.0, v46);
                                            // Rule at src/opts/extends.isle line 3.
                                            returns.extend(Some(v1314));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        _ => {}
                                    }
                                }
                                _ => {}
                            }
                        }
                        let v292 = C::fits_in_64(ctx, v2.0);
                        if let Some(v293) = v292 {
                            let mut v981 = C::inst_data_value_tupled_etor_returns::default();
                            C::inst_data_value_tupled_etor(ctx, v33, &mut v981);
                            let mut v981 = v981.into_context_iter();
                            while let Some(v982) = v981.next(ctx) {
                                let v983 = C::iconst_sextend_etor(ctx, v982);
                                if let Some(v984) = v983 {
                                    let v987 = constructor_iconst_s(ctx, v293, v984.1);
                                    let v988 = C::subsume(ctx, v987);
                                    // Rule at src/opts/cprop.isle line 131.
                                    returns.extend(Some(v988));
                                    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 v1816 = C::lane_type(ctx, v2.0);
                                            let v1949 = constructor_fcvt_from_uint(ctx, v1816, v46);
                                            let v1950 = constructor_splat(ctx, v2.0, v1949);
                                            // Rule at src/opts/vector.isle line 6.
                                            returns.extend(Some(v1950));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Uextend => {
                                            let v130 = constructor_fcvt_from_uint(ctx, v2.0, v46);
                                            // Rule at src/opts/arithmetic.isle line 219.
                                            returns.extend(Some(v130));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v917,
                                    imm: v918,
                                } => {
                                    if let &Opcode::Iconst = v917 {
                                        match v2.0 {
                                            F32 => {
                                                let v975 = C::u64_from_imm64(ctx, v918);
                                                let v1113 = C::f32_from_uint(ctx, v975);
                                                let v1114 = constructor_f32const(ctx, F32, v1113);
                                                // Rule at src/opts/cprop.isle line 336.
                                                returns.extend(Some(v1114));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            F64 => {
                                                let v975 = C::u64_from_imm64(ctx, v918);
                                                let v1116 = C::f64_from_uint(ctx, v975);
                                                let v1117 = constructor_f64const(ctx, F64, v1116);
                                                // Rule at src/opts/cprop.isle line 338.
                                                returns.extend(Some(v1117));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            _ => {}
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                    }
                    &Opcode::FcvtFromSint => {
                        match v2.0 {
                            F32 => {
                                let mut v981 = C::inst_data_value_tupled_etor_returns::default();
                                C::inst_data_value_tupled_etor(ctx, v33, &mut v981);
                                let mut v981 = v981.into_context_iter();
                                while let Some(v982) = v981.next(ctx) {
                                    let v983 = C::iconst_sextend_etor(ctx, v982);
                                    if let Some(v984) = v983 {
                                        let v1118 = C::f32_from_sint(ctx, v984.1);
                                        let v1119 = constructor_f32const(ctx, F32, v1118);
                                        // Rule at src/opts/cprop.isle line 340.
                                        returns.extend(Some(v1119));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                            }
                            F64 => {
                                let mut v981 = C::inst_data_value_tupled_etor_returns::default();
                                C::inst_data_value_tupled_etor(ctx, v33, &mut v981);
                                let mut v981 = v981.into_context_iter();
                                while let Some(v982) = v981.next(ctx) {
                                    let v983 = C::iconst_sextend_etor(ctx, v982);
                                    if let Some(v984) = v983 {
                                        let v1120 = C::f64_from_sint(ctx, v984.1);
                                        let v1121 = constructor_f64const(ctx, F64, v1120);
                                        // Rule at src/opts/cprop.isle line 342.
                                        returns.extend(Some(v1121));
                                        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 v1816 = C::lane_type(ctx, v2.0);
                                        let v1951 = constructor_fcvt_from_sint(ctx, v1816, v46);
                                        let v1952 = constructor_splat(ctx, v2.0, v1951);
                                        // Rule at src/opts/vector.isle line 8.
                                        returns.extend(Some(v1952));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                    &Opcode::Sextend => {
                                        let v131 = constructor_fcvt_from_sint(ctx, v2.0, v46);
                                        // Rule at src/opts/arithmetic.isle line 221.
                                        returns.extend(Some(v131));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                    _ => {}
                                }
                            }
                        }
                    }
                    _ => {}
                }
            }
            &InstructionData::UnaryIeee32 {
                opcode: ref v1575,
                imm: v1576,
            } => {
                if let &Opcode::F32const = v1575 {
                    let v1572 = C::remat(ctx, arg0);
                    // Rule at src/opts/remat.isle line 27.
                    returns.extend(Some(v1572));
                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                }
            }
            &InstructionData::UnaryIeee64 {
                opcode: ref v1577,
                imm: v1578,
            } => {
                if let &Opcode::F64const = v1577 {
                    let v1572 = C::remat(ctx, arg0);
                    // Rule at src/opts/remat.isle line 29.
                    returns.extend(Some(v1572));
                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                }
            }
            &InstructionData::UnaryImm {
                opcode: ref v1573,
                imm: v1574,
            } => {
                if let &Opcode::Iconst = v1573 {
                    let v1572 = C::remat(ctx, arg0);
                    // Rule at src/opts/remat.isle line 25.
                    returns.extend(Some(v1572));
                    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 v186,
                                    args: ref v187,
                                } => {
                                    if let &Opcode::Select = v186 {
                                        let v188 = C::unpack_value_array_3(ctx, v187);
                                        let mut v192 = C::inst_data_value_etor_returns::default();
                                        C::inst_data_value_etor(ctx, v188.1, &mut v192);
                                        let mut v192 = v192.into_context_iter();
                                        while let Some(v193) = v192.next(ctx) {
                                            if let &InstructionData::UnaryImm {
                                                opcode: ref v196,
                                                imm: v197,
                                            } = &v193.1 {
                                                if let &Opcode::Iconst = v196 {
                                                    let v198 = C::imm64_power_of_two(ctx, v197);
                                                    if let Some(v199) = v198 {
                                                        if v16.0 == v193.0 {
                                                            let mut v200 = C::inst_data_value_etor_returns::default();
                                                            C::inst_data_value_etor(ctx, v188.2, &mut v200);
                                                            let mut v200 = v200.into_context_iter();
                                                            while let Some(v201) = v200.next(ctx) {
                                                                if let &InstructionData::UnaryImm {
                                                                    opcode: ref v204,
                                                                    imm: v205,
                                                                } = &v201.1 {
                                                                    if let &Opcode::Iconst = v204 {
                                                                        let v206 = C::imm64_power_of_two(ctx, v205);
                                                                        if let Some(v207) = v206 {
                                                                            if v16.0 == v201.0 {
                                                                                let v208 = C::imm64(ctx, v199);
                                                                                let v209 = constructor_iconst(ctx, v16.0, v208);
                                                                                let v210 = C::imm64(ctx, v207);
                                                                                let v211 = constructor_iconst(ctx, v16.0, v210);
                                                                                let v212 = constructor_select(ctx, v16.0, v188.0, v209, v211);
                                                                                let v213 = constructor_ushr(ctx, v16.0, v5.0, v212);
                                                                                let v214 = &constructor_value_to_skeleton_inst_simplification(ctx, v213);
                                                                                // Rule at src/opts/skeleton.isle line 40.
                                                                                returns.extend(Some(v214.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::imm64_udiv(ctx, v122.0, v126, v20);
                                                    if let Some(v136) = v135 {
                                                        if v16.0 == v122.0 {
                                                            let v137 = constructor_iconst(ctx, v122.0, v136);
                                                            let v138 = &constructor_value_to_skeleton_inst_simplification(ctx, v137);
                                                            // Rule at src/opts/cprop.isle line 43.
                                                            returns.extend(Some(v138.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 v139 = C::imm64_urem(ctx, v122.0, v126, v20);
                                                if let Some(v140) = v139 {
                                                    if v16.0 == v122.0 {
                                                        let v141 = constructor_iconst(ctx, v122.0, v140);
                                                        let v142 = &constructor_value_to_skeleton_inst_simplification(ctx, v141);
                                                        // Rule at src/opts/cprop.isle line 49.
                                                        returns.extend(Some(v142.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 v143,
                arg: v144,
                code: ref v145,
            } => {
                match v143 {
                    &Opcode::Trapz => {
                        let mut v146 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v144, &mut v146);
                        let mut v146 = v146.into_context_iter();
                        while let Some(v147) = v146.next(ctx) {
                            if let &InstructionData::UnaryImm {
                                opcode: ref v150,
                                imm: v151,
                            } = &v147.1 {
                                if let &Opcode::Iconst = v150 {
                                    let v152 = C::u64_from_imm64(ctx, v151);
                                    let v153 = C::u64_matches_non_zero(ctx, v152);
                                    if let Some(v154) = v153 {
                                        if v154 == true {
                                            let v155 = &constructor_remove_inst(ctx);
                                            // Rule at src/opts/skeleton.isle line 6.
                                            returns.extend(Some(v155.clone()));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    &Opcode::Trapnz => {
                        let mut v146 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v144, &mut v146);
                        let mut v146 = v146.into_context_iter();
                        while let Some(v147) = v146.next(ctx) {
                            if let &InstructionData::UnaryImm {
                                opcode: ref v150,
                                imm: v151,
                            } = &v147.1 {
                                if let &Opcode::Iconst = v150 {
                                    let v152 = C::u64_from_imm64(ctx, v151);
                                    if v152 == 0x0_u64 {
                                        let v155 = &constructor_remove_inst(ctx);
                                        // Rule at src/opts/skeleton.isle line 8.
                                        returns.extend(Some(v155.clone()));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                            }
                        }
                    }
                    _ => {}
                }
            }
            &InstructionData::IntAddTrap {
                opcode: ref v156,
                args: ref v157,
                code: ref v158,
            } => {
                if let &Opcode::UaddOverflowTrap = v156 {
                    let v159 = C::unpack_value_array_2(ctx, v157);
                    let mut v162 = C::inst_data_value_etor_returns::default();
                    C::inst_data_value_etor(ctx, v159.0, &mut v162);
                    let mut v162 = v162.into_context_iter();
                    while let Some(v163) = v162.next(ctx) {
                        match &v163.1 {
                            &InstructionData::Unary {
                                opcode: ref v180,
                                arg: v181,
                            } => {
                                if let &Opcode::Uextend = v180 {
                                    let mut v169 = C::inst_data_value_etor_returns::default();
                                    C::inst_data_value_etor(ctx, v159.1, &mut v169);
                                    let mut v169 = v169.into_context_iter();
                                    while let Some(v170) = v169.next(ctx) {
                                        if let &InstructionData::Unary {
                                            opcode: ref v182,
                                            arg: v183,
                                        } = &v170.1 {
                                            if let &Opcode::Uextend = v182 {
                                                if v163.0 == v170.0 {
                                                    let v184 = constructor_iadd(ctx, v163.0, v159.0, v159.1);
                                                    let v185 = &constructor_value_to_skeleton_inst_simplification(ctx, v184);
                                                    // Rule at src/opts/skeleton.isle line 17.
                                                    returns.extend(Some(v185.clone()));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            &InstructionData::UnaryImm {
                                opcode: ref v166,
                                imm: v167,
                            } => {
                                if let &Opcode::Iconst = v166 {
                                    let mut v169 = C::inst_data_value_etor_returns::default();
                                    C::inst_data_value_etor(ctx, v159.1, &mut v169);
                                    let mut v169 = v169.into_context_iter();
                                    while let Some(v170) = v169.next(ctx) {
                                        if let &InstructionData::UnaryImm {
                                            opcode: ref v173,
                                            imm: v174,
                                        } = &v170.1 {
                                            if let &Opcode::Iconst = v173 {
                                                let v168 = C::u64_from_imm64(ctx, v167);
                                                let v175 = C::u64_from_imm64(ctx, v174);
                                                let v176 = C::checked_add_with_type(ctx, v163.0, v168, v175);
                                                if let Some(v177) = v176 {
                                                    if v163.0 == v170.0 {
                                                        let v178 = constructor_iconst_u(ctx, v163.0, v177);
                                                        let v179 = &constructor_value_to_skeleton_inst_simplification(ctx, v178);
                                                        // Rule at src/opts/skeleton.isle line 12.
                                                        returns.extend(Some(v179.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 {
    let v17 = C::ty_vec128(ctx, arg0);
    if let Some(v18) = v17 {
        let v19 = C::lane_type(ctx, v18);
        let v20 = constructor_iconst_s(ctx, v19, arg1);
        let v21 = constructor_splat(ctx, v18, v20);
        // Rule at src/prelude_opt.isle line 155.
        return v21;
    }
    if arg0 == I128 {
        let v15 = constructor_iconst_s(ctx, I64, arg1);
        let v16 = constructor_sextend(ctx, I128, v15);
        // Rule at src/prelude_opt.isle line 154.
        return v16;
    }
    let v1 = C::ty_int(ctx, arg0);
    if let Some(v2) = v1 {
        let v3 = C::fits_in_64(ctx, v2);
        if let Some(v4) = v3 {
            let v6 = C::i64_cast_unsigned(ctx, arg1);
            let v7 = C::ty_umax(ctx, v4);
            let v8 = C::u64_and(ctx, v6, v7);
            let v9 = C::i64_sextend_u64(ctx, v4, v8);
            let v10 = C::i64_eq(ctx, arg1, v9);
            if v10 == true {
                let v11 = C::imm64(ctx, v8);
                let v12 = constructor_iconst(ctx, v4, v11);
                // Rule at src/prelude_opt.isle line 148.
                return v12;
            }
        }
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "iconst_s", "src/prelude_opt.isle line 146")
}

// Generated as internal constructor for term iconst_u.
pub fn constructor_iconst_u<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: u64,
) -> Value {
    let v14 = C::ty_vec128(ctx, arg0);
    if let Some(v15) = v14 {
        let v16 = C::lane_type(ctx, v15);
        let v17 = constructor_iconst_u(ctx, v16, arg1);
        let v18 = constructor_splat(ctx, v15, v17);
        // Rule at src/prelude_opt.isle line 171.
        return v18;
    }
    if arg0 == I128 {
        let v12 = constructor_iconst_u(ctx, I64, arg1);
        let v13 = constructor_uextend(ctx, I128, v12);
        // Rule at src/prelude_opt.isle line 170.
        return v13;
    }
    let v1 = C::ty_int(ctx, arg0);
    if let Some(v2) = v1 {
        let v3 = C::fits_in_64(ctx, v2);
        if let Some(v4) = v3 {
            let v6 = C::ty_umax(ctx, v4);
            let v7 = C::u64_lt_eq(ctx, arg1, v6);
            if v7 == true {
                let v8 = C::imm64(ctx, arg1);
                let v9 = constructor_iconst(ctx, v4, v8);
                // Rule at src/prelude_opt.isle line 167.
                return v9;
            }
        }
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "iconst_u", "src/prelude_opt.isle line 165")
}

// 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 191.
        return arg1;
    }
    let v2 = constructor_uextend(ctx, arg0, arg1);
    // Rule at src/prelude_opt.isle line 190.
    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 197.
        return arg1;
    }
    let v2 = constructor_sextend(ctx, arg0, arg1);
    // Rule at src/prelude_opt.isle line 196.
    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 234.
    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 238.
        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 241.
        return v3;
    }
    let v5 = false;
    // Rule at src/prelude_opt.isle line 244.
    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 273.
    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 278.
        return v11;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "apply_div_const_magic_u32_inner", "src/prelude_opt.isle line 277")
}

// 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 303.
                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 294.
                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 293")
}

// 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 317.
            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 323.
                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 316")
}

// 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 343.
            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 344.
            return v8;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "apply_div_const_magic_u32_finish", "src/prelude_opt.isle line 342")
}

// 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 350.
    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 355.
        return v10;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "apply_div_const_magic_u64_inner", "src/prelude_opt.isle line 354")
}

// 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 380.
                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 371.
                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 370")
}

// 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 394.
            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 400.
                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 393")
}

// 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 420.
            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 421.
            return v7;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "apply_div_const_magic_u64_finish", "src/prelude_opt.isle line 419")
}

// 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 428.
    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 434.
        return v10;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "apply_div_const_magic_s32_inner", "src/prelude_opt.isle line 433")
}

// 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 450.
                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 459.
                return v16;
            }
        }
    }
    let v17 = constructor_apply_div_const_magic_s32_shift(ctx, arg0, arg1, arg2, arg3, arg4);
    // Rule at src/prelude_opt.isle line 468.
    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 479.
        return v15;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "apply_div_const_magic_s32_shift", "src/prelude_opt.isle line 478")
}

// 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 503.
            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 500.
            return v8;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "apply_div_const_magic_s32_finish", "src/prelude_opt.isle line 499")
}

// 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 509.
    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 515.
        return v9;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "apply_div_const_magic_s64_inner", "src/prelude_opt.isle line 514")
}

// 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 531.
                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 540.
                return v16;
            }
        }
    }
    let v17 = constructor_apply_div_const_magic_s64_shift(ctx, arg0, arg1, arg2, arg3, arg4);
    // Rule at src/prelude_opt.isle line 549.
    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 560.
        return v15;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "apply_div_const_magic_s64_shift", "src/prelude_opt.isle line 559")
}

// 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 584.
            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 581.
            return v7;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "apply_div_const_magic_s64_finish", "src/prelude_opt.isle line 580")
}

// Generated as internal constructor for term cmp_true.
pub fn constructor_cmp_true<C: Context>(
    ctx: &mut C,
    arg0: Type,
) -> Value {
    let v5 = C::ty_vec128(ctx, arg0);
    if let Some(v6) = v5 {
        let v8 = constructor_iconst_s(ctx, v6, -1_i64);
        // Rule at src/opts/arithmetic.isle line 348.
        return v8;
    }
    let v1 = C::ty_int(ctx, arg0);
    if let Some(v2) = v1 {
        let v4 = constructor_iconst_u(ctx, v2, 0x1_u64);
        // Rule at src/opts/arithmetic.isle line 347.
        return v4;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "cmp_true", "src/opts/arithmetic.isle line 346")
}

// 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 289.
    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 291.
    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 293.
    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 208.
            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 213.
            return 0x1_u64;
        }
        &IntCC::NotEqual => {
            // Rule at src/opts/icmp.isle line 222.
            return 0x6_u64;
        }
        &IntCC::SignedGreaterThan => {
            // Rule at src/opts/icmp.isle line 219.
            return 0x4_u64;
        }
        &IntCC::SignedGreaterThanOrEqual => {
            // Rule at src/opts/icmp.isle line 221.
            return 0x5_u64;
        }
        &IntCC::SignedLessThan => {
            // Rule at src/opts/icmp.isle line 215.
            return 0x2_u64;
        }
        &IntCC::SignedLessThanOrEqual => {
            // Rule at src/opts/icmp.isle line 217.
            return 0x3_u64;
        }
        &IntCC::UnsignedGreaterThan => {
            // Rule at src/opts/icmp.isle line 218.
            return 0x4_u64;
        }
        &IntCC::UnsignedGreaterThanOrEqual => {
            // Rule at src/opts/icmp.isle line 220.
            return 0x5_u64;
        }
        &IntCC::UnsignedLessThan => {
            // Rule at src/opts/icmp.isle line 214.
            return 0x2_u64;
        }
        &IntCC::UnsignedLessThanOrEqual => {
            // Rule at src/opts/icmp.isle line 216.
            return 0x3_u64;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "decompose_intcc", "src/opts/icmp.isle line 212")
}

// 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 225.
            return v7;
        }
        0x1_u64 => {
            let v9 = constructor_icmp(ctx, arg0, &IntCC::Equal, arg3, arg4);
            // Rule at src/opts/icmp.isle line 226.
            return v9;
        }
        0x2_u64 => {
            match arg2 {
                false => {
                    let v11 = constructor_icmp(ctx, arg0, &IntCC::UnsignedLessThan, arg3, arg4);
                    // Rule at src/opts/icmp.isle line 227.
                    return v11;
                }
                true => {
                    let v13 = constructor_icmp(ctx, arg0, &IntCC::SignedLessThan, arg3, arg4);
                    // Rule at src/opts/icmp.isle line 228.
                    return v13;
                }
                _ => {}
            }
        }
        0x3_u64 => {
            match arg2 {
                false => {
                    let v15 = constructor_icmp(ctx, arg0, &IntCC::UnsignedLessThanOrEqual, arg3, arg4);
                    // Rule at src/opts/icmp.isle line 229.
                    return v15;
                }
                true => {
                    let v17 = constructor_icmp(ctx, arg0, &IntCC::SignedLessThanOrEqual, arg3, arg4);
                    // Rule at src/opts/icmp.isle line 230.
                    return v17;
                }
                _ => {}
            }
        }
        0x4_u64 => {
            match arg2 {
                false => {
                    let v19 = constructor_icmp(ctx, arg0, &IntCC::UnsignedGreaterThan, arg3, arg4);
                    // Rule at src/opts/icmp.isle line 231.
                    return v19;
                }
                true => {
                    let v21 = constructor_icmp(ctx, arg0, &IntCC::SignedGreaterThan, arg3, arg4);
                    // Rule at src/opts/icmp.isle line 232.
                    return v21;
                }
                _ => {}
            }
        }
        0x5_u64 => {
            match arg2 {
                false => {
                    let v23 = constructor_icmp(ctx, arg0, &IntCC::UnsignedGreaterThanOrEqual, arg3, arg4);
                    // Rule at src/opts/icmp.isle line 233.
                    return v23;
                }
                true => {
                    let v25 = constructor_icmp(ctx, arg0, &IntCC::SignedGreaterThanOrEqual, arg3, arg4);
                    // Rule at src/opts/icmp.isle line 234.
                    return v25;
                }
                _ => {}
            }
        }
        0x6_u64 => {
            let v27 = constructor_icmp(ctx, arg0, &IntCC::NotEqual, arg3, arg4);
            // Rule at src/opts/icmp.isle line 235.
            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 236.
            return v30;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "compose_icmp", "src/opts/icmp.isle line 224")
}

// 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 247.
            return 0x3_u64;
        }
        &IntCC::NotEqual => {
            // Rule at src/opts/icmp.isle line 248.
            return 0x3_u64;
        }
        &IntCC::SignedGreaterThan => {
            // Rule at src/opts/icmp.isle line 245.
            return 0x2_u64;
        }
        &IntCC::SignedGreaterThanOrEqual => {
            // Rule at src/opts/icmp.isle line 246.
            return 0x2_u64;
        }
        &IntCC::SignedLessThan => {
            // Rule at src/opts/icmp.isle line 243.
            return 0x2_u64;
        }
        &IntCC::SignedLessThanOrEqual => {
            // Rule at src/opts/icmp.isle line 244.
            return 0x2_u64;
        }
        &IntCC::UnsignedGreaterThan => {
            // Rule at src/opts/icmp.isle line 241.
            return 0x1_u64;
        }
        &IntCC::UnsignedGreaterThanOrEqual => {
            // Rule at src/opts/icmp.isle line 242.
            return 0x1_u64;
        }
        &IntCC::UnsignedLessThan => {
            // Rule at src/opts/icmp.isle line 239.
            return 0x1_u64;
        }
        &IntCC::UnsignedLessThanOrEqual => {
            // Rule at src/opts/icmp.isle line 240.
            return 0x1_u64;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "intcc_class", "src/opts/icmp.isle line 238")
}

// 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;
}
