// 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 mem_flags_data(&mut self, arg0: MemFlags) -> Option<MemFlagsData>;
    fn mem_flags_intern(&mut self, arg0: MemFlagsData) -> MemFlags;
    fn mem_flags_trusted_data(&mut self, ) -> MemFlagsData;
    fn little_or_native_endian(&mut self, arg0: MemFlags) -> Option<MemFlagsData>;
    fn intcc_swap_args(&mut self, arg0: &IntCC) -> IntCC;
    fn intcc_complement(&mut self, arg0: &IntCC) -> IntCC;
    fn intcc_without_eq(&mut self, arg0: &IntCC) -> IntCC;
    fn floatcc_swap_args(&mut self, arg0: &FloatCC) -> FloatCC;
    fn floatcc_complement(&mut self, arg0: &FloatCC) -> FloatCC;
    fn floatcc_unordered(&mut self, arg0: &FloatCC) -> bool;
    fn fits_in_16(&mut self, arg0: Type) -> Option<Type>;
    fn fits_in_32(&mut self, arg0: Type) -> Option<Type>;
    fn lane_fits_in_32(&mut self, arg0: Type) -> Option<Type>;
    fn fits_in_64(&mut self, arg0: Type) -> Option<Type>;
    fn ty_16(&mut self, arg0: Type) -> Option<Type>;
    fn ty_32(&mut self, arg0: Type) -> Option<Type>;
    fn ty_64(&mut self, arg0: Type) -> Option<Type>;
    fn ty_128(&mut self, arg0: Type) -> Option<Type>;
    fn ty_int_ref_scalar_64_extract(&mut self, arg0: Type) -> Option<Type>;
    fn ty_int_ref_scalar_64(&mut self, arg0: Type) -> Option<Type>;
    fn ty_32_or_64(&mut self, arg0: Type) -> Option<Type>;
    fn ty_8_or_16(&mut self, arg0: Type) -> Option<Type>;
    fn ty_16_or_32(&mut self, arg0: Type) -> Option<Type>;
    fn int_fits_in_32(&mut self, arg0: Type) -> Option<Type>;
    fn ty_int_ref_64(&mut self, arg0: Type) -> Option<Type>;
    fn ty_int_ref_16_to_64(&mut self, arg0: Type) -> Option<Type>;
    fn ty_int(&mut self, arg0: Type) -> Option<Type>;
    fn ty_scalar(&mut self, arg0: Type) -> Option<Type>;
    fn ty_scalar_float(&mut self, arg0: Type) -> Option<Type>;
    fn ty_float_or_vec(&mut self, arg0: Type) -> Option<Type>;
    fn ty_vector_float(&mut self, arg0: Type) -> Option<Type>;
    fn ty_vector_not_float(&mut self, arg0: Type) -> Option<Type>;
    fn ty_vec64(&mut self, arg0: Type) -> Option<Type>;
    fn ty_vec64_ctor(&mut self, arg0: Type) -> Option<Type>;
    fn ty_vec128(&mut self, arg0: Type) -> Option<Type>;
    fn ty_int_vec128(&mut self, arg0: Type) -> Option<Type>;
    fn ty_dyn_vec64(&mut self, arg0: Type) -> Option<Type>;
    fn ty_dyn_vec128(&mut self, arg0: Type) -> Option<Type>;
    fn ty_vec64_int(&mut self, arg0: Type) -> Option<Type>;
    fn ty_vec128_int(&mut self, arg0: Type) -> Option<Type>;
    fn ty_addr64(&mut self, arg0: Type) -> Option<Type>;
    fn not_vec32x2(&mut self, arg0: Type) -> Option<Type>;
    fn not_i64x2(&mut self, arg0: Type) -> Option<()>;
    fn u8_from_uimm8(&mut self, arg0: Uimm8) -> u8;
    fn u64_from_bool(&mut self, arg0: bool) -> u64;
    fn u64_from_imm64(&mut self, arg0: Imm64) -> u64;
    fn nonzero_u64_from_imm64(&mut self, arg0: Imm64) -> Option<u64>;
    fn imm64_power_of_two(&mut self, arg0: Imm64) -> Option<u64>;
    fn imm64(&mut self, arg0: u64) -> Imm64;
    fn imm64_masked(&mut self, arg0: Type, arg1: u64) -> Imm64;
    fn u16_from_ieee16(&mut self, arg0: Ieee16) -> u16;
    fn u32_from_ieee32(&mut self, arg0: Ieee32) -> u32;
    fn u64_from_ieee64(&mut self, arg0: Ieee64) -> u64;
    fn multi_lane(&mut self, arg0: Type) -> Option<(u32, u32)>;
    fn dynamic_lane(&mut self, arg0: Type) -> Option<(u32, u32)>;
    fn ty_dyn64_int(&mut self, arg0: Type) -> Option<Type>;
    fn ty_dyn128_int(&mut self, arg0: Type) -> Option<Type>;
    fn offset32_to_i32(&mut self, arg0: Offset32) -> i32;
    fn i32_to_offset32(&mut self, arg0: i32) -> Offset32;
    fn intcc_unsigned(&mut self, arg0: &IntCC) -> IntCC;
    fn signed_cond_code(&mut self, arg0: &IntCC) -> Option<IntCC>;
    fn unsigned_cond_code(&mut self, arg0: &IntCC) -> Option<IntCC>;
    fn trap_code_division_by_zero(&mut self, ) -> TrapCode;
    fn trap_code_integer_overflow(&mut self, ) -> TrapCode;
    fn trap_code_bad_conversion_to_integer(&mut self, ) -> TrapCode;
    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 resolve_jump_table_entry(&mut self, arg0: JumpTable, arg1: u64) -> BlockCall;
    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 69.
#[derive(Clone, Debug)]
pub enum SkeletonInstSimplification {
    Remove,
    RemoveWithVal {
        val: Value,
    },
    Replace {
        inst: Inst,
    },
    ReplaceWithVal {
        inst: Inst,
        val: Value,
    },
    ReplaceBranchCond {
        cond: Value,
    },
}

/// Internal type DivConstMagicU32: defined at src/prelude_opt.isle line 264.
#[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 267.
#[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 270.
#[derive(Clone, Debug)]
pub enum DivConstMagicS32 {
    S32 {
        mul_by: i32,
        shift_by: u32,
    },
}

/// Internal type DivConstMagicS64: defined at src/prelude_opt.isle line 272.
#[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 57.
    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 60.
    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 v331 = constructor_smin(ctx, v2.0, v104.0, v104.1);
                                                                                // Rule at src/opts/arithmetic.isle line 484.
                                                                                returns.extend(Some(v331));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                        if v104.0 == v140.1 {
                                                                            if v104.1 == v140.0 {
                                                                                let v331 = constructor_smin(ctx, v2.0, v104.0, v104.1);
                                                                                // Rule at src/opts/arithmetic.isle line 485.
                                                                                returns.extend(Some(v331));
                                                                                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 v331 = constructor_smin(ctx, v2.0, v104.0, v104.1);
                                                                                // Rule at src/opts/arithmetic.isle line 486.
                                                                                returns.extend(Some(v331));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                        if v104.0 == v140.1 {
                                                                            if v104.1 == v140.0 {
                                                                                let v331 = constructor_smin(ctx, v2.0, v104.0, v104.1);
                                                                                // Rule at src/opts/arithmetic.isle line 487.
                                                                                returns.extend(Some(v331));
                                                                                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 v1073 = constructor_smin(ctx, v2.0, v104.1, v7.1);
                                                                                    let v1074 = constructor_smin(ctx, v2.0, v104.0, v1073);
                                                                                    // Rule at src/opts/cprop.isle line 237.
                                                                                    returns.extend(Some(v1074));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let v104 = C::unpack_value_array_2(ctx, v103);
                                                if v7.1 == v104.0 {
                                                    let v331 = constructor_smin(ctx, v2.0, v104.0, v104.1);
                                                    // Rule at src/opts/arithmetic.isle line 451.
                                                    returns.extend(Some(v331));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.1 == v104.1 {
                                                    let v332 = constructor_smin(ctx, v2.0, v104.1, v104.0);
                                                    // Rule at src/opts/arithmetic.isle line 452.
                                                    returns.extend(Some(v332));
                                                    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 v335 = constructor_umin(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 494.
                                                                            returns.extend(Some(v335));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        if v104.1 == v140.0 {
                                                                            let v335 = constructor_umin(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 495.
                                                                            returns.extend(Some(v335));
                                                                            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 v331 = constructor_smin(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 496.
                                                                            returns.extend(Some(v331));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        if v104.1 == v140.0 {
                                                                            let v331 = constructor_smin(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 497.
                                                                            returns.extend(Some(v331));
                                                                            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 v331 = constructor_smin(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 479.
                                                                            returns.extend(Some(v331));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        if v104.1 == v140.0 {
                                                                            let v331 = constructor_smin(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 480.
                                                                            returns.extend(Some(v331));
                                                                            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 v335 = constructor_umin(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 481.
                                                                            returns.extend(Some(v335));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        if v104.1 == v140.0 {
                                                                            let v335 = constructor_umin(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 482.
                                                                            returns.extend(Some(v335));
                                                                            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 462.
                                                    returns.extend(Some(v104.0));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.1 == v104.1 {
                                                    // Rule at src/opts/arithmetic.isle line 461.
                                                    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 v331 = constructor_smin(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 489.
                                                                            returns.extend(Some(v331));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        if v104.1 == v140.0 {
                                                                            let v331 = constructor_smin(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 490.
                                                                            returns.extend(Some(v331));
                                                                            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 v331 = constructor_smin(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 491.
                                                                            returns.extend(Some(v331));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        if v104.1 == v140.0 {
                                                                            let v331 = constructor_smin(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 492.
                                                                            returns.extend(Some(v331));
                                                                            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 v1854 = C::lane_type(ctx, v2.0);
                                                            let v2016 = constructor_smin(ctx, v1854, v30, v27);
                                                            let v2017 = constructor_splat(ctx, v2.0, v2016);
                                                            // Rule at src/opts/vector.isle line 54.
                                                            returns.extend(Some(v2017));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v22,
                                    imm: v23,
                                } => {
                                    if let &Opcode::Iconst = v22 {
                                        let v339 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v340) = v339 {
                                            if v19.0 == v340 {
                                                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 v999 = C::imm64_smin(ctx, v340, v23, v15);
                                                                let v1000 = constructor_iconst(ctx, v340, v999);
                                                                let v1001 = C::subsume(ctx, v1000);
                                                                // Rule at src/opts/cprop.isle line 113.
                                                                returns.extend(Some(v1001));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        if v2.0 == v19.0 {
                                            let v1031 = constructor_smin(ctx, v2.0, v7.1, v7.0);
                                            // Rule at src/opts/cprop.isle line 168.
                                            returns.extend(Some(v1031));
                                            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 v333 = constructor_smin(ctx, v2.0, v7.0, v140.1);
                                                // Rule at src/opts/arithmetic.isle line 453.
                                                returns.extend(Some(v333));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            if v7.0 == v140.1 {
                                                let v334 = constructor_smin(ctx, v2.0, v7.0, v140.0);
                                                // Rule at src/opts/arithmetic.isle line 454.
                                                returns.extend(Some(v334));
                                                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 464.
                                                returns.extend(Some(v7.0));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            if v7.0 == v140.1 {
                                                // Rule at src/opts/arithmetic.isle line 463.
                                                returns.extend(Some(v7.0));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                        }
                        if v7.0 == v7.1 {
                            // Rule at src/opts/arithmetic.isle line 436.
                            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 v335 = constructor_umin(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 504.
                                                                            returns.extend(Some(v335));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        if v104.1 == v140.0 {
                                                                            let v335 = constructor_umin(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 505.
                                                                            returns.extend(Some(v335));
                                                                            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 v331 = constructor_smin(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 506.
                                                                            returns.extend(Some(v331));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        if v104.1 == v140.0 {
                                                                            let v331 = constructor_smin(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 507.
                                                                            returns.extend(Some(v331));
                                                                            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 v335 = constructor_umin(ctx, v2.0, v104.0, v104.1);
                                                                                // Rule at src/opts/arithmetic.isle line 514.
                                                                                returns.extend(Some(v335));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                        if v104.0 == v140.1 {
                                                                            if v104.1 == v140.0 {
                                                                                let v335 = constructor_umin(ctx, v2.0, v104.0, v104.1);
                                                                                // Rule at src/opts/arithmetic.isle line 515.
                                                                                returns.extend(Some(v335));
                                                                                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 v335 = constructor_umin(ctx, v2.0, v104.0, v104.1);
                                                                                // Rule at src/opts/arithmetic.isle line 516.
                                                                                returns.extend(Some(v335));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                        if v104.0 == v140.1 {
                                                                            if v104.1 == v140.0 {
                                                                                let v335 = constructor_umin(ctx, v2.0, v104.0, v104.1);
                                                                                // Rule at src/opts/arithmetic.isle line 517.
                                                                                returns.extend(Some(v335));
                                                                                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 v1069 = constructor_umin(ctx, v2.0, v104.1, v7.1);
                                                                                    let v1070 = constructor_umin(ctx, v2.0, v104.0, v1069);
                                                                                    // Rule at src/opts/cprop.isle line 231.
                                                                                    returns.extend(Some(v1070));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let v104 = C::unpack_value_array_2(ctx, v103);
                                                if v7.1 == v104.0 {
                                                    let v335 = constructor_umin(ctx, v2.0, v104.0, v104.1);
                                                    // Rule at src/opts/arithmetic.isle line 455.
                                                    returns.extend(Some(v335));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.1 == v104.1 {
                                                    let v336 = constructor_umin(ctx, v2.0, v104.1, v104.0);
                                                    // Rule at src/opts/arithmetic.isle line 456.
                                                    returns.extend(Some(v336));
                                                    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 v335 = constructor_umin(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 499.
                                                                            returns.extend(Some(v335));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        if v104.1 == v140.0 {
                                                                            let v335 = constructor_umin(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 500.
                                                                            returns.extend(Some(v335));
                                                                            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 v335 = constructor_umin(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 501.
                                                                            returns.extend(Some(v335));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        if v104.1 == v140.0 {
                                                                            let v335 = constructor_umin(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 502.
                                                                            returns.extend(Some(v335));
                                                                            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 v331 = constructor_smin(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 509.
                                                                            returns.extend(Some(v331));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        if v104.1 == v140.0 {
                                                                            let v331 = constructor_smin(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 510.
                                                                            returns.extend(Some(v331));
                                                                            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 v335 = constructor_umin(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 511.
                                                                            returns.extend(Some(v335));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        if v104.1 == v140.0 {
                                                                            let v335 = constructor_umin(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 512.
                                                                            returns.extend(Some(v335));
                                                                            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 466.
                                                    returns.extend(Some(v104.0));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.1 == v104.1 {
                                                    // Rule at src/opts/arithmetic.isle line 465.
                                                    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 v1854 = C::lane_type(ctx, v2.0);
                                                            let v2018 = constructor_umin(ctx, v1854, v30, v27);
                                                            let v2019 = constructor_splat(ctx, v2.0, v2018);
                                                            // Rule at src/opts/vector.isle line 57.
                                                            returns.extend(Some(v2019));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v22,
                                    imm: v23,
                                } => {
                                    if let &Opcode::Iconst = v22 {
                                        let v339 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v340) = v339 {
                                            if v19.0 == v340 {
                                                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 v993 = C::imm64_umin(ctx, v340, v23, v15);
                                                                let v994 = constructor_iconst(ctx, v340, v993);
                                                                let v995 = C::subsume(ctx, v994);
                                                                // Rule at src/opts/cprop.isle line 103.
                                                                returns.extend(Some(v995));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        if v2.0 == v19.0 {
                                            let v1032 = constructor_umin(ctx, v2.0, v7.1, v7.0);
                                            // Rule at src/opts/cprop.isle line 169.
                                            returns.extend(Some(v1032));
                                            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 v337 = constructor_umin(ctx, v2.0, v7.0, v140.1);
                                                // Rule at src/opts/arithmetic.isle line 457.
                                                returns.extend(Some(v337));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            if v7.0 == v140.1 {
                                                let v338 = constructor_umin(ctx, v2.0, v7.0, v140.0);
                                                // Rule at src/opts/arithmetic.isle line 458.
                                                returns.extend(Some(v338));
                                                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 468.
                                                returns.extend(Some(v7.0));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            if v7.0 == v140.1 {
                                                // Rule at src/opts/arithmetic.isle line 467.
                                                returns.extend(Some(v7.0));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                        }
                        if v7.0 == v7.1 {
                            // Rule at src/opts/arithmetic.isle line 435.
                            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 v323 = constructor_smax(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 525.
                                                                            returns.extend(Some(v323));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        if v104.1 == v140.0 {
                                                                            let v323 = constructor_smax(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 526.
                                                                            returns.extend(Some(v323));
                                                                            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 v327 = constructor_umax(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 527.
                                                                            returns.extend(Some(v327));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        if v104.1 == v140.0 {
                                                                            let v327 = constructor_umax(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 528.
                                                                            returns.extend(Some(v327));
                                                                            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 470.
                                                    returns.extend(Some(v104.0));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.1 == v104.1 {
                                                    // Rule at src/opts/arithmetic.isle line 469.
                                                    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 v323 = constructor_smax(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 535.
                                                                            returns.extend(Some(v323));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        if v104.1 == v140.0 {
                                                                            let v323 = constructor_smax(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 536.
                                                                            returns.extend(Some(v323));
                                                                            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 v323 = constructor_smax(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 537.
                                                                            returns.extend(Some(v323));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        if v104.1 == v140.0 {
                                                                            let v323 = constructor_smax(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 538.
                                                                            returns.extend(Some(v323));
                                                                            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 v323 = constructor_smax(ctx, v2.0, v104.0, v104.1);
                                                                                // Rule at src/opts/arithmetic.isle line 520.
                                                                                returns.extend(Some(v323));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                        if v104.0 == v140.1 {
                                                                            if v104.1 == v140.0 {
                                                                                let v323 = constructor_smax(ctx, v2.0, v104.0, v104.1);
                                                                                // Rule at src/opts/arithmetic.isle line 521.
                                                                                returns.extend(Some(v323));
                                                                                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 v323 = constructor_smax(ctx, v2.0, v104.0, v104.1);
                                                                                // Rule at src/opts/arithmetic.isle line 522.
                                                                                returns.extend(Some(v323));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                        if v104.0 == v140.1 {
                                                                            if v104.1 == v140.0 {
                                                                                let v323 = constructor_smax(ctx, v2.0, v104.0, v104.1);
                                                                                // Rule at src/opts/arithmetic.isle line 523.
                                                                                returns.extend(Some(v323));
                                                                                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 v1075 = constructor_smax(ctx, v2.0, v104.1, v7.1);
                                                                                    let v1076 = constructor_smax(ctx, v2.0, v104.0, v1075);
                                                                                    // Rule at src/opts/cprop.isle line 240.
                                                                                    returns.extend(Some(v1076));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let v104 = C::unpack_value_array_2(ctx, v103);
                                                if v7.1 == v104.0 {
                                                    let v323 = constructor_smax(ctx, v2.0, v104.0, v104.1);
                                                    // Rule at src/opts/arithmetic.isle line 441.
                                                    returns.extend(Some(v323));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.1 == v104.1 {
                                                    let v324 = constructor_smax(ctx, v2.0, v104.1, v104.0);
                                                    // Rule at src/opts/arithmetic.isle line 442.
                                                    returns.extend(Some(v324));
                                                    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 v327 = constructor_umax(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 530.
                                                                            returns.extend(Some(v327));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        if v104.1 == v140.0 {
                                                                            let v327 = constructor_umax(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 531.
                                                                            returns.extend(Some(v327));
                                                                            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 v323 = constructor_smax(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 532.
                                                                            returns.extend(Some(v323));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        if v104.1 == v140.0 {
                                                                            let v323 = constructor_smax(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 533.
                                                                            returns.extend(Some(v323));
                                                                            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 v1854 = C::lane_type(ctx, v2.0);
                                                            let v2020 = constructor_smax(ctx, v1854, v30, v27);
                                                            let v2021 = constructor_splat(ctx, v2.0, v2020);
                                                            // Rule at src/opts/vector.isle line 60.
                                                            returns.extend(Some(v2021));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v22,
                                    imm: v23,
                                } => {
                                    if let &Opcode::Iconst = v22 {
                                        let v339 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v340) = v339 {
                                            if v19.0 == v340 {
                                                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 v1002 = C::imm64_smax(ctx, v340, v23, v15);
                                                                let v1003 = constructor_iconst(ctx, v340, v1002);
                                                                let v1004 = C::subsume(ctx, v1003);
                                                                // Rule at src/opts/cprop.isle line 118.
                                                                returns.extend(Some(v1004));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        if v2.0 == v19.0 {
                                            let v1033 = constructor_smax(ctx, v2.0, v7.1, v7.0);
                                            // Rule at src/opts/cprop.isle line 170.
                                            returns.extend(Some(v1033));
                                            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 472.
                                                returns.extend(Some(v7.0));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            if v7.0 == v140.1 {
                                                // Rule at src/opts/arithmetic.isle line 471.
                                                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 v325 = constructor_smax(ctx, v2.0, v7.0, v140.1);
                                                // Rule at src/opts/arithmetic.isle line 443.
                                                returns.extend(Some(v325));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            if v7.0 == v140.1 {
                                                let v326 = constructor_smax(ctx, v2.0, v7.0, v140.0);
                                                // Rule at src/opts/arithmetic.isle line 444.
                                                returns.extend(Some(v326));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                        }
                        if v7.0 == v7.1 {
                            // Rule at src/opts/arithmetic.isle line 438.
                            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 v327 = constructor_umax(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 545.
                                                                            returns.extend(Some(v327));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        if v104.1 == v140.0 {
                                                                            let v327 = constructor_umax(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 546.
                                                                            returns.extend(Some(v327));
                                                                            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 v327 = constructor_umax(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 547.
                                                                            returns.extend(Some(v327));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        if v104.1 == v140.0 {
                                                                            let v327 = constructor_umax(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 548.
                                                                            returns.extend(Some(v327));
                                                                            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 v323 = constructor_smax(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 555.
                                                                            returns.extend(Some(v323));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        if v104.1 == v140.0 {
                                                                            let v323 = constructor_smax(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 556.
                                                                            returns.extend(Some(v323));
                                                                            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 v327 = constructor_umax(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 557.
                                                                            returns.extend(Some(v327));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        if v104.1 == v140.0 {
                                                                            let v327 = constructor_umax(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 558.
                                                                            returns.extend(Some(v327));
                                                                            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 474.
                                                    returns.extend(Some(v104.0));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.1 == v104.1 {
                                                    // Rule at src/opts/arithmetic.isle line 473.
                                                    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 v327 = constructor_umax(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 540.
                                                                            returns.extend(Some(v327));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        if v104.1 == v140.0 {
                                                                            let v327 = constructor_umax(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 541.
                                                                            returns.extend(Some(v327));
                                                                            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 v323 = constructor_smax(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 542.
                                                                            returns.extend(Some(v323));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v104.0 == v140.1 {
                                                                        if v104.1 == v140.0 {
                                                                            let v323 = constructor_smax(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/arithmetic.isle line 543.
                                                                            returns.extend(Some(v323));
                                                                            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 v327 = constructor_umax(ctx, v2.0, v104.0, v104.1);
                                                                                // Rule at src/opts/arithmetic.isle line 550.
                                                                                returns.extend(Some(v327));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                        if v104.0 == v140.1 {
                                                                            if v104.1 == v140.0 {
                                                                                let v327 = constructor_umax(ctx, v2.0, v104.0, v104.1);
                                                                                // Rule at src/opts/arithmetic.isle line 551.
                                                                                returns.extend(Some(v327));
                                                                                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 v327 = constructor_umax(ctx, v2.0, v104.0, v104.1);
                                                                                // Rule at src/opts/arithmetic.isle line 552.
                                                                                returns.extend(Some(v327));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                        if v104.0 == v140.1 {
                                                                            if v104.1 == v140.0 {
                                                                                let v327 = constructor_umax(ctx, v2.0, v104.0, v104.1);
                                                                                // Rule at src/opts/arithmetic.isle line 553.
                                                                                returns.extend(Some(v327));
                                                                                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 v1071 = constructor_umax(ctx, v2.0, v104.1, v7.1);
                                                                                    let v1072 = constructor_umax(ctx, v2.0, v104.0, v1071);
                                                                                    // Rule at src/opts/cprop.isle line 234.
                                                                                    returns.extend(Some(v1072));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let v104 = C::unpack_value_array_2(ctx, v103);
                                                if v7.1 == v104.0 {
                                                    let v327 = constructor_umax(ctx, v2.0, v104.0, v104.1);
                                                    // Rule at src/opts/arithmetic.isle line 445.
                                                    returns.extend(Some(v327));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.1 == v104.1 {
                                                    let v328 = constructor_umax(ctx, v2.0, v104.1, v104.0);
                                                    // Rule at src/opts/arithmetic.isle line 446.
                                                    returns.extend(Some(v328));
                                                    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 v1854 = C::lane_type(ctx, v2.0);
                                                            let v2022 = constructor_umax(ctx, v1854, v30, v27);
                                                            let v2023 = constructor_splat(ctx, v2.0, v2022);
                                                            // Rule at src/opts/vector.isle line 63.
                                                            returns.extend(Some(v2023));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v22,
                                    imm: v23,
                                } => {
                                    if let &Opcode::Iconst = v22 {
                                        let v339 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v340) = v339 {
                                            if v19.0 == v340 {
                                                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 v996 = C::imm64_umax(ctx, v340, v23, v15);
                                                                let v997 = constructor_iconst(ctx, v340, v996);
                                                                let v998 = C::subsume(ctx, v997);
                                                                // Rule at src/opts/cprop.isle line 108.
                                                                returns.extend(Some(v998));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        if v2.0 == v19.0 {
                                            let v1034 = constructor_umax(ctx, v2.0, v7.1, v7.0);
                                            // Rule at src/opts/cprop.isle line 171.
                                            returns.extend(Some(v1034));
                                            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 476.
                                                returns.extend(Some(v7.0));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            if v7.0 == v140.1 {
                                                // Rule at src/opts/arithmetic.isle line 475.
                                                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 v329 = constructor_umax(ctx, v2.0, v7.0, v140.1);
                                                // Rule at src/opts/arithmetic.isle line 447.
                                                returns.extend(Some(v329));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            if v7.0 == v140.1 {
                                                let v330 = constructor_umax(ctx, v2.0, v7.0, v140.0);
                                                // Rule at src/opts/arithmetic.isle line 448.
                                                returns.extend(Some(v330));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                        }
                        if v7.0 == v7.1 {
                            // Rule at src/opts/arithmetic.isle line 437.
                            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::Smin => {
                                            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::Smax = 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 v255 = constructor_iadd(ctx, v2.0, v104.0, v104.1);
                                                                        // Rule at src/opts/arithmetic.isle line 347.
                                                                        returns.extend(Some(v255));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        let v256 = constructor_iadd(ctx, v2.0, v104.1, v104.0);
                                                                        // Rule at src/opts/arithmetic.isle line 353.
                                                                        returns.extend(Some(v256));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                                if v104.0 == v140.1 {
                                                                    if v104.1 == v140.0 {
                                                                        let v256 = constructor_iadd(ctx, v2.0, v104.1, v104.0);
                                                                        // Rule at src/opts/arithmetic.isle line 349.
                                                                        returns.extend(Some(v256));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        let v255 = constructor_iadd(ctx, v2.0, v104.0, v104.1);
                                                                        // Rule at src/opts/arithmetic.isle line 351.
                                                                        returns.extend(Some(v255));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Umin => {
                                            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::Umax = 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 v255 = constructor_iadd(ctx, v2.0, v104.0, v104.1);
                                                                        // Rule at src/opts/arithmetic.isle line 337.
                                                                        returns.extend(Some(v255));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        let v256 = constructor_iadd(ctx, v2.0, v104.1, v104.0);
                                                                        // Rule at src/opts/arithmetic.isle line 343.
                                                                        returns.extend(Some(v256));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                                if v104.0 == v140.1 {
                                                                    if v104.1 == v140.0 {
                                                                        let v256 = constructor_iadd(ctx, v2.0, v104.1, v104.0);
                                                                        // Rule at src/opts/arithmetic.isle line 339.
                                                                        returns.extend(Some(v256));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        let v255 = constructor_iadd(ctx, v2.0, v104.0, v104.1);
                                                                        // Rule at src/opts/arithmetic.isle line 341.
                                                                        returns.extend(Some(v255));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Smax => {
                                            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::Smin = 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 v255 = constructor_iadd(ctx, v2.0, v104.0, v104.1);
                                                                        // Rule at src/opts/arithmetic.isle line 346.
                                                                        returns.extend(Some(v255));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        let v256 = constructor_iadd(ctx, v2.0, v104.1, v104.0);
                                                                        // Rule at src/opts/arithmetic.isle line 352.
                                                                        returns.extend(Some(v256));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                                if v104.0 == v140.1 {
                                                                    if v104.1 == v140.0 {
                                                                        let v255 = constructor_iadd(ctx, v2.0, v104.0, v104.1);
                                                                        // Rule at src/opts/arithmetic.isle line 348.
                                                                        returns.extend(Some(v255));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        let v256 = constructor_iadd(ctx, v2.0, v104.1, v104.0);
                                                                        // Rule at src/opts/arithmetic.isle line 350.
                                                                        returns.extend(Some(v256));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Umax => {
                                            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::Umin = 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 v255 = constructor_iadd(ctx, v2.0, v104.0, v104.1);
                                                                        // Rule at src/opts/arithmetic.isle line 336.
                                                                        returns.extend(Some(v255));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        let v256 = constructor_iadd(ctx, v2.0, v104.1, v104.0);
                                                                        // Rule at src/opts/arithmetic.isle line 342.
                                                                        returns.extend(Some(v256));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                                if v104.0 == v140.1 {
                                                                    if v104.1 == v140.0 {
                                                                        let v255 = constructor_iadd(ctx, v2.0, v104.0, v104.1);
                                                                        // Rule at src/opts/arithmetic.isle line 338.
                                                                        returns.extend(Some(v255));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        let v256 = constructor_iadd(ctx, v2.0, v104.1, v104.0);
                                                                        // Rule at src/opts/arithmetic.isle line 340.
                                                                        returns.extend(Some(v256));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &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,
                                                        } => {
                                                            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 {
                                                                                    let v140 = C::unpack_value_array_2(ctx, v139);
                                                                                    let mut v263 = C::inst_data_value_etor_returns::default();
                                                                                    C::inst_data_value_etor(ctx, v140.1, &mut v263);
                                                                                    let mut v263 = v263.into_context_iter();
                                                                                    while let Some(v264) = v263.next(ctx) {
                                                                                        if let &InstructionData::UnaryImm {
                                                                                            opcode: ref v1129,
                                                                                            imm: v1130,
                                                                                        } = &v264.1 {
                                                                                            if let &Opcode::Iconst = v1129 {
                                                                                                let v259 = constructor_iadd(ctx, v2.0, v104.0, v140.0);
                                                                                                let v1131 = constructor_iadd(ctx, v2.0, v104.1, v140.1);
                                                                                                let v1132 = constructor_iadd(ctx, v2.0, v259, v1131);
                                                                                                // Rule at src/opts/cprop.isle line 313.
                                                                                                returns.extend(Some(v1132));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Isub => {
                                                                    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.0 {
                                                                            let v257 = constructor_iadd(ctx, v2.0, v104.0, v140.1);
                                                                            // Rule at src/opts/arithmetic.isle line 362.
                                                                            returns.extend(Some(v257));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v104.1 == v140.1 {
                                                                            let v259 = constructor_iadd(ctx, v2.0, v104.0, v140.0);
                                                                            // Rule at src/opts/arithmetic.isle line 364.
                                                                            returns.extend(Some(v259));
                                                                            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; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let v140 = C::unpack_value_array_2(ctx, v139);
                                                let mut v263 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v140.1, &mut v263);
                                                let mut v263 = v263.into_context_iter();
                                                while let Some(v264) = v263.next(ctx) {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v267,
                                                        args: ref v268,
                                                    } = &v264.1 {
                                                        if let &Opcode::Isub = v267 {
                                                            if v2.0 == v264.0 {
                                                                let v269 = C::unpack_value_array_2(ctx, v268);
                                                                if v7.0 == v269.1 {
                                                                    let v272 = constructor_iadd(ctx, v2.0, v140.0, v269.0);
                                                                    // Rule at src/opts/arithmetic.isle line 372.
                                                                    returns.extend(Some(v272));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                let mut v279 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v140.0, &mut v279);
                                                let mut v279 = v279.into_context_iter();
                                                while let Some(v280) = v279.next(ctx) {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v283,
                                                        args: ref v284,
                                                    } = &v280.1 {
                                                        if let &Opcode::Isub = v283 {
                                                            if v2.0 == v280.0 {
                                                                let v285 = C::unpack_value_array_2(ctx, v284);
                                                                if v7.0 == v285.1 {
                                                                    let v288 = constructor_iadd(ctx, v2.0, v140.1, v285.0);
                                                                    // Rule at src/opts/arithmetic.isle line 374.
                                                                    returns.extend(Some(v288));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Isub => {
                                            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::Iadd = 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.1 {
                                                                    let v258 = constructor_iadd(ctx, v2.0, v140.0, v104.1);
                                                                    // Rule at src/opts/arithmetic.isle line 363.
                                                                    returns.extend(Some(v258));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v104.1 == v140.1 {
                                                                    let v260 = constructor_iadd(ctx, v2.0, v140.0, v104.0);
                                                                    // Rule at src/opts/arithmetic.isle line 365.
                                                                    returns.extend(Some(v260));
                                                                    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/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 v255 = constructor_iadd(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/bitops.isle line 208.
                                                                            returns.extend(Some(v255));
                                                                            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 v255 = constructor_iadd(ctx, v2.0, v104.0, v104.1);
                                                                            // Rule at src/opts/bitops.isle line 209.
                                                                            returns.extend(Some(v255));
                                                                            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 v640 = constructor_bnot(ctx, v2.0, v30);
                                                                        let v672 = constructor_band(ctx, v2.0, v140.1, v640);
                                                                        // Rule at src/opts/bitops.isle line 245.
                                                                        returns.extend(Some(v672));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v30 == v140.1 {
                                                                        let v640 = constructor_bnot(ctx, v2.0, v30);
                                                                        let v670 = constructor_band(ctx, v2.0, v140.0, v640);
                                                                        // Rule at src/opts/bitops.isle line 241.
                                                                        returns.extend(Some(v670));
                                                                        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 v259 = constructor_iadd(ctx, v2.0, v104.0, v140.0);
                                                                    let v1911 = constructor_ishl(ctx, v2.0, v259, v104.1);
                                                                    // Rule at src/opts/shifts.isle line 314.
                                                                    returns.extend(Some(v1911));
                                                                    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 v1854 = C::lane_type(ctx, v2.0);
                                                                let v2000 = constructor_iadd(ctx, v1854, v30, v27);
                                                                let v2001 = constructor_splat(ctx, v2.0, v2000);
                                                                // Rule at src/opts/vector.isle line 30.
                                                                returns.extend(Some(v2001));
                                                                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 v638 = constructor_bnot(ctx, v2.0, v104.0);
                                                                        let v671 = constructor_band(ctx, v2.0, v104.1, v638);
                                                                        // Rule at src/opts/bitops.isle line 243.
                                                                        returns.extend(Some(v671));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v27 == v104.1 {
                                                                        let v668 = constructor_bnot(ctx, v2.0, v104.1);
                                                                        let v669 = constructor_band(ctx, v2.0, v104.0, v668);
                                                                        // Rule at src/opts/bitops.isle line 239.
                                                                        returns.extend(Some(v669));
                                                                        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 v1037 = constructor_iadd(ctx, v2.0, v104.1, v7.1);
                                                                                    let v1038 = constructor_iadd(ctx, v2.0, v104.0, v1037);
                                                                                    // Rule at src/opts/cprop.isle line 182.
                                                                                    returns.extend(Some(v1038));
                                                                                    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 v1042,
                                                                            imm: v1043,
                                                                        } = &v108.1 {
                                                                            if let &Opcode::Iconst = v1042 {
                                                                                if v2.0 == v108.0 {
                                                                                    let v1051 = C::imm64_add(ctx, v2.0, v1043, v15);
                                                                                    let v1052 = constructor_iconst(ctx, v2.0, v1051);
                                                                                    let v1053 = constructor_isub(ctx, v2.0, v1052, v104.1);
                                                                                    // Rule at src/opts/cprop.isle line 208.
                                                                                    returns.extend(Some(v1053));
                                                                                    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 v1047 = C::imm64_sub(ctx, v2.0, v15, v133);
                                                                                    let v1048 = constructor_iconst(ctx, v2.0, v1047);
                                                                                    let v1050 = constructor_iadd(ctx, v2.0, v104.0, v1048);
                                                                                    // Rule at src/opts/cprop.isle line 204.
                                                                                    returns.extend(Some(v1050));
                                                                                    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 v1674,
                                                        args: ref v1675,
                                                    } => {
                                                        if let &Opcode::Select = v1674 {
                                                            if v2.0 == v19.0 {
                                                                let v1676 = C::unpack_value_array_3(ctx, v1675);
                                                                let mut v1680 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v1676.1, &mut v1680);
                                                                let mut v1680 = v1680.into_context_iter();
                                                                while let Some(v1681) = v1680.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v1684,
                                                                        imm: v1685,
                                                                    } = &v1681.1 {
                                                                        if let &Opcode::Iconst = v1684 {
                                                                            if v2.0 == v1681.0 {
                                                                                let mut v1686 = C::inst_data_value_etor_returns::default();
                                                                                C::inst_data_value_etor(ctx, v1676.2, &mut v1686);
                                                                                let mut v1686 = v1686.into_context_iter();
                                                                                while let Some(v1687) = v1686.next(ctx) {
                                                                                    if let &InstructionData::UnaryImm {
                                                                                        opcode: ref v1690,
                                                                                        imm: v1691,
                                                                                    } = &v1687.1 {
                                                                                        if let &Opcode::Iconst = v1690 {
                                                                                            if v2.0 == v1687.0 {
                                                                                                let v1692 = C::imm64_add(ctx, v2.0, v1685, v15);
                                                                                                let v1693 = constructor_iconst(ctx, v2.0, v1692);
                                                                                                let v1694 = C::imm64_add(ctx, v2.0, v1691, v15);
                                                                                                let v1695 = constructor_iconst(ctx, v2.0, v1694);
                                                                                                let v1696 = constructor_select(ctx, v2.0, v1676.0, v1693, v1695);
                                                                                                // Rule at src/opts/selects.isle line 95.
                                                                                                returns.extend(Some(v1696));
                                                                                                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 v339 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v340) = v339 {
                                            if v11.0 == v340 {
                                                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 v957 = C::imm64_add(ctx, v340, v23, v15);
                                                                let v958 = constructor_iconst(ctx, v340, v957);
                                                                let v959 = C::subsume(ctx, v958);
                                                                // Rule at src/opts/cprop.isle line 13.
                                                                returns.extend(Some(v959));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        let v1610 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 5.
                                        returns.extend(Some(v1610));
                                        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::Iadd => {
                                            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 v289,
                                                        args: ref v290,
                                                    } = &v108.1 {
                                                        if let &Opcode::Isub = v289 {
                                                            if v2.0 == v108.0 {
                                                                let v291 = C::unpack_value_array_2(ctx, v290);
                                                                if v7.1 == v291.1 {
                                                                    let v294 = constructor_iadd(ctx, v2.0, v104.1, v291.0);
                                                                    // Rule at src/opts/arithmetic.isle line 375.
                                                                    returns.extend(Some(v294));
                                                                    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 v273,
                                                        args: ref v274,
                                                    } = &v115.1 {
                                                        if let &Opcode::Isub = v273 {
                                                            if v2.0 == v115.0 {
                                                                let v275 = C::unpack_value_array_2(ctx, v274);
                                                                if v7.1 == v275.1 {
                                                                    let v278 = constructor_iadd(ctx, v2.0, v104.0, v275.0);
                                                                    // Rule at src/opts/arithmetic.isle line 373.
                                                                    returns.extend(Some(v278));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Isub => {
                                            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 v1024 = constructor_iadd(ctx, v2.0, v7.1, v7.0);
                                            // Rule at src/opts/cprop.isle line 146.
                                            returns.extend(Some(v1024));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        let v1610 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 3.
                                        returns.extend(Some(v1610));
                                        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::Iadd => {
                                                                    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 {
                                                                            let v250 = constructor_isub(ctx, v2.0, v104.1, v140.1);
                                                                            // Rule at src/opts/arithmetic.isle line 324.
                                                                            returns.extend(Some(v250));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            // Rule at src/opts/arithmetic.isle line 359.
                                                                            returns.extend(Some(v250));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v104.0 == v140.1 {
                                                                            let v251 = constructor_isub(ctx, v2.0, v104.1, v140.0);
                                                                            // Rule at src/opts/arithmetic.isle line 325.
                                                                            returns.extend(Some(v251));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            // Rule at src/opts/arithmetic.isle line 358.
                                                                            returns.extend(Some(v251));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v104.1 == v140.0 {
                                                                            let v252 = constructor_isub(ctx, v2.0, v104.0, v140.1);
                                                                            // Rule at src/opts/arithmetic.isle line 326.
                                                                            returns.extend(Some(v252));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            // Rule at src/opts/arithmetic.isle line 357.
                                                                            returns.extend(Some(v252));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v104.1 == v140.1 {
                                                                            let v253 = constructor_isub(ctx, v2.0, v104.0, v140.0);
                                                                            // Rule at src/opts/arithmetic.isle line 327.
                                                                            returns.extend(Some(v253));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            // Rule at src/opts/arithmetic.isle line 356.
                                                                            returns.extend(Some(v253));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                &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 v1047 = C::imm64_sub(ctx, v2.0, v15, v133);
                                                                                    let v1048 = constructor_iconst(ctx, v2.0, v1047);
                                                                                    let v1049 = constructor_isub(ctx, v2.0, v104.0, v1048);
                                                                                    // Rule at src/opts/cprop.isle line 200.
                                                                                    returns.extend(Some(v1049));
                                                                                    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) {
                                                    match &v11.1 {
                                                        &InstructionData::Binary {
                                                            opcode: ref v138,
                                                            args: ref v139,
                                                        } => {
                                                            if let &Opcode::Isub = 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.0 == v140.0 {
                                                                        let v254 = constructor_isub(ctx, v2.0, v140.1, v104.1);
                                                                        // Rule at src/opts/arithmetic.isle line 333.
                                                                        returns.extend(Some(v254));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v104.1 == v140.1 {
                                                                        let v253 = constructor_isub(ctx, v2.0, v104.0, v140.0);
                                                                        // Rule at src/opts/arithmetic.isle line 330.
                                                                        returns.extend(Some(v253));
                                                                        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 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 v1042,
                                                                            imm: v1043,
                                                                        } = &v108.1 {
                                                                            if let &Opcode::Iconst = v1042 {
                                                                                if v2.0 == v108.0 {
                                                                                    let v1044 = C::imm64_sub(ctx, v2.0, v1043, v15);
                                                                                    let v1045 = constructor_iconst(ctx, v2.0, v1044);
                                                                                    let v1046 = constructor_isub(ctx, v2.0, v1045, v104.1);
                                                                                    // Rule at src/opts/cprop.isle line 196.
                                                                                    returns.extend(Some(v1046));
                                                                                    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 v1039 = C::imm64_add(ctx, v2.0, v133, v15);
                                                                                    let v1040 = constructor_iconst(ctx, v2.0, v1039);
                                                                                    let v1041 = constructor_isub(ctx, v2.0, v104.0, v1040);
                                                                                    // Rule at src/opts/cprop.isle line 192.
                                                                                    returns.extend(Some(v1041));
                                                                                    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::Band => {
                                            if v2.0 == v19.0 {
                                                let mut v10 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
                                                let mut v10 = v10.into_context_iter();
                                                while let Some(v11) = v10.next(ctx) {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v138,
                                                        args: ref v139,
                                                    } = &v11.1 {
                                                        if let &Opcode::Band = 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.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 v873 = constructor_bxor(ctx, v2.0, v104.0, v119);
                                                                                        let v874 = constructor_isub(ctx, v2.0, v873, v119);
                                                                                        // Rule at src/opts/bitops.isle line 538.
                                                                                        returns.extend(Some(v874));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    let mut v263 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v140.1, &mut v263);
                                                                    let mut v263 = v263.into_context_iter();
                                                                    while let Some(v264) = v263.next(ctx) {
                                                                        if let &InstructionData::Unary {
                                                                            opcode: ref v632,
                                                                            arg: v633,
                                                                        } = &v264.1 {
                                                                            if let &Opcode::Bnot = v632 {
                                                                                if v104.1 == v633 {
                                                                                    if v2.0 == v264.0 {
                                                                                        let v243 = constructor_bxor(ctx, v2.0, v104.0, v104.1);
                                                                                        let v877 = constructor_isub(ctx, v2.0, v104.1, v243);
                                                                                        // Rule at src/opts/bitops.isle line 542.
                                                                                        returns.extend(Some(v877));
                                                                                        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 v873 = constructor_bxor(ctx, v2.0, v104.0, v119);
                                                                                        let v874 = constructor_isub(ctx, v2.0, v873, v119);
                                                                                        // Rule at src/opts/bitops.isle line 539.
                                                                                        returns.extend(Some(v874));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    let mut v279 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v140.0, &mut v279);
                                                                    let mut v279 = v279.into_context_iter();
                                                                    while let Some(v280) = v279.next(ctx) {
                                                                        if let &InstructionData::Unary {
                                                                            opcode: ref v635,
                                                                            arg: v636,
                                                                        } = &v280.1 {
                                                                            if let &Opcode::Bnot = v635 {
                                                                                if v104.1 == v636 {
                                                                                    if v2.0 == v280.0 {
                                                                                        let v243 = constructor_bxor(ctx, v2.0, v104.0, v104.1);
                                                                                        let v877 = constructor_isub(ctx, v2.0, v104.1, v243);
                                                                                        // Rule at src/opts/bitops.isle line 543.
                                                                                        returns.extend(Some(v877));
                                                                                        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 v875 = constructor_bxor(ctx, v2.0, v104.1, v112);
                                                                                        let v876 = constructor_isub(ctx, v2.0, v875, v112);
                                                                                        // Rule at src/opts/bitops.isle line 540.
                                                                                        returns.extend(Some(v876));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    let mut v263 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v140.1, &mut v263);
                                                                    let mut v263 = v263.into_context_iter();
                                                                    while let Some(v264) = v263.next(ctx) {
                                                                        if let &InstructionData::Unary {
                                                                            opcode: ref v632,
                                                                            arg: v633,
                                                                        } = &v264.1 {
                                                                            if let &Opcode::Bnot = v632 {
                                                                                if v104.0 == v633 {
                                                                                    if v2.0 == v264.0 {
                                                                                        let v244 = constructor_bxor(ctx, v2.0, v104.1, v104.0);
                                                                                        let v878 = constructor_isub(ctx, v2.0, v104.0, v244);
                                                                                        // Rule at src/opts/bitops.isle line 544.
                                                                                        returns.extend(Some(v878));
                                                                                        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 v875 = constructor_bxor(ctx, v2.0, v104.1, v112);
                                                                                        let v876 = constructor_isub(ctx, v2.0, v875, v112);
                                                                                        // Rule at src/opts/bitops.isle line 541.
                                                                                        returns.extend(Some(v876));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    let mut v279 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v140.0, &mut v279);
                                                                    let mut v279 = v279.into_context_iter();
                                                                    while let Some(v280) = v279.next(ctx) {
                                                                        if let &InstructionData::Unary {
                                                                            opcode: ref v635,
                                                                            arg: v636,
                                                                        } = &v280.1 {
                                                                            if let &Opcode::Bnot = v635 {
                                                                                if v104.0 == v636 {
                                                                                    if v2.0 == v280.0 {
                                                                                        let v244 = constructor_bxor(ctx, v2.0, v104.1, v104.0);
                                                                                        let v878 = constructor_isub(ctx, v2.0, v104.0, v244);
                                                                                        // Rule at src/opts/bitops.isle line 545.
                                                                                        returns.extend(Some(v878));
                                                                                        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 v253 = constructor_isub(ctx, v2.0, v104.0, v140.0);
                                                                    let v1910 = constructor_ishl(ctx, v2.0, v253, v104.1);
                                                                    // Rule at src/opts/shifts.isle line 313.
                                                                    returns.extend(Some(v1910));
                                                                    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 v1854 = C::lane_type(ctx, v2.0);
                                                                let v2002 = constructor_isub(ctx, v1854, v30, v27);
                                                                let v2003 = constructor_splat(ctx, v2.0, v2002);
                                                                // Rule at src/opts/vector.isle line 33.
                                                                returns.extend(Some(v2003));
                                                                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 v929 = constructor_isub(ctx, v2.0, v27, v30);
                                                                // Rule at src/opts/bitops.isle line 648.
                                                                returns.extend(Some(v929));
                                                                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 v1025 = constructor_isub(ctx, v2.0, v7.1, v7.0);
                                            let v1026 = constructor_ineg(ctx, v2.0, v1025);
                                            // Rule at src/opts/cprop.isle line 151.
                                            returns.extend(Some(v1026));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        let v339 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v340) = v339 {
                                            if v19.0 == v340 {
                                                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 v960 = C::imm64_sub(ctx, v340, v23, v15);
                                                                let v961 = constructor_iconst(ctx, v340, v960);
                                                                let v962 = C::subsume(ctx, v961);
                                                                // Rule at src/opts/cprop.isle line 19.
                                                                returns.extend(Some(v962));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        let v1610 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 7.
                                        returns.extend(Some(v1610));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                _ => {}
                            }
                        }
                        let mut v10 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v7.1, &mut v10);
                        let mut v10 = v10.into_context_iter();
                        while let Some(v11) = v10.next(ctx) {
                            match &v11.1 {
                                &InstructionData::Binary {
                                    opcode: ref v138,
                                    args: ref v139,
                                } => {
                                    if let &Opcode::Iadd = v138 {
                                        if v2.0 == v11.0 {
                                            let v140 = C::unpack_value_array_2(ctx, v139);
                                            if v7.0 == v140.0 {
                                                let v261 = constructor_ineg(ctx, v2.0, v140.1);
                                                // Rule at src/opts/arithmetic.isle line 368.
                                                returns.extend(Some(v261));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            if v7.0 == v140.1 {
                                                let v262 = constructor_ineg(ctx, v2.0, v140.0);
                                                // Rule at src/opts/arithmetic.isle line 369.
                                                returns.extend(Some(v262));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v26,
                                    arg: v27,
                                } => {
                                    if let &Opcode::Ineg = v26 {
                                        if v2.0 == v11.0 {
                                            let 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 v1610 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 9.
                                        returns.extend(Some(v1610));
                                        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 v1087 = C::i64_wrapping_neg(ctx, v59.1);
                                let v1088 = C::i64_cast_unsigned(ctx, v1087);
                                let v1089 = C::i64_cast_unsigned(ctx, v59.1);
                                let v1090 = C::u64_lt(ctx, v1088, v1089);
                                if v1090 == true {
                                    if v2.0 == v59.0 {
                                        let v1091 = C::imm64(ctx, v1089);
                                        let v1092 = C::imm64_neg(ctx, v2.0, v1091);
                                        let v1093 = constructor_iconst(ctx, v2.0, v1092);
                                        let v1094 = constructor_iadd(ctx, v2.0, v7.0, v1093);
                                        // Rule at src/opts/cprop.isle line 268.
                                        returns.extend(Some(v1094));
                                        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 v263 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v140.1, &mut v263);
                                                                            let mut v263 = v263.into_context_iter();
                                                                            while let Some(v264) = v263.next(ctx) {
                                                                                if let &InstructionData::UnaryImm {
                                                                                    opcode: ref v1129,
                                                                                    imm: v1130,
                                                                                } = &v264.1 {
                                                                                    if let &Opcode::Iconst = v1129 {
                                                                                        let v1133 = constructor_imul(ctx, v2.0, v104.0, v140.0);
                                                                                        let v1134 = constructor_imul(ctx, v2.0, v104.1, v140.1);
                                                                                        let v1135 = constructor_imul(ctx, v2.0, v1133, v1134);
                                                                                        // Rule at src/opts/cprop.isle line 317.
                                                                                        returns.extend(Some(v1135));
                                                                                        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 v1854 = C::lane_type(ctx, v2.0);
                                                                let v2004 = constructor_imul(ctx, v1854, v30, v27);
                                                                let v2005 = constructor_splat(ctx, v2.0, v2004);
                                                                // Rule at src/opts/vector.isle line 36.
                                                                returns.extend(Some(v2005));
                                                                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 v1054 = constructor_imul(ctx, v2.0, v104.1, v7.1);
                                                                                let v1055 = constructor_imul(ctx, v2.0, v104.0, v1054);
                                                                                // Rule at src/opts/cprop.isle line 213.
                                                                                returns.extend(Some(v1055));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                &InstructionData::Unary {
                                                    opcode: ref v29,
                                                    arg: v30,
                                                } => {
                                                    if let &Opcode::Ineg = v29 {
                                                        let v339 = C::fits_in_64(ctx, v2.0);
                                                        if let Some(v340) = v339 {
                                                            if v11.0 == v19.0 {
                                                                if v11.0 == v340 {
                                                                    let v341 = C::imm64_neg(ctx, v340, v15);
                                                                    let v342 = constructor_iconst(ctx, v340, v341);
                                                                    let v343 = constructor_imul(ctx, v340, v30, v342);
                                                                    // Rule at src/opts/arithmetic.isle line 571.
                                                                    returns.extend(Some(v343));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                &InstructionData::UnaryImm {
                                                    opcode: ref v22,
                                                    imm: v23,
                                                } => {
                                                    if let &Opcode::Iconst = v22 {
                                                        let v339 = C::fits_in_64(ctx, v2.0);
                                                        if let Some(v340) = v339 {
                                                            if v11.0 == v19.0 {
                                                                if v11.0 == v340 {
                                                                    let v963 = C::imm64_mul(ctx, v340, v23, v15);
                                                                    let v964 = constructor_iconst(ctx, v340, v963);
                                                                    let v965 = C::subsume(ctx, v964);
                                                                    // Rule at src/opts/cprop.isle line 25.
                                                                    returns.extend(Some(v965));
                                                                    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 v1027 = constructor_imul(ctx, v2.0, v7.1, v7.0);
                                        // Rule at src/opts/cprop.isle line 154.
                                        returns.extend(Some(v1027));
                                        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 v1854 = C::lane_type(ctx, v2.0);
                                                        let v2008 = constructor_umulhi(ctx, v1854, v30, v27);
                                                        let v2009 = constructor_splat(ctx, v2.0, v2008);
                                                        // Rule at src/opts/vector.isle line 42.
                                                        returns.extend(Some(v2009));
                                                        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 v1854 = C::lane_type(ctx, v2.0);
                                                        let v2006 = constructor_smulhi(ctx, v1854, v30, v27);
                                                        let v2007 = constructor_splat(ctx, v2.0, v2006);
                                                        // Rule at src/opts/vector.isle line 39.
                                                        returns.extend(Some(v2007));
                                                        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 v628 = constructor_band(ctx, v2.0, v7.0, v140.1);
                                                    // Rule at src/opts/bitops.isle line 194.
                                                    returns.extend(Some(v628));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.0 == v140.1 {
                                                    let v629 = constructor_band(ctx, v2.0, v140.0, v7.0);
                                                    // Rule at src/opts/bitops.isle line 195.
                                                    returns.extend(Some(v629));
                                                    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 v263 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v140.1, &mut v263);
                                                                            let mut v263 = v263.into_context_iter();
                                                                            while let Some(v264) = v263.next(ctx) {
                                                                                if let &InstructionData::UnaryImm {
                                                                                    opcode: ref v1129,
                                                                                    imm: v1130,
                                                                                } = &v264.1 {
                                                                                    if let &Opcode::Iconst = v1129 {
                                                                                        let v673 = constructor_band(ctx, v2.0, v104.0, v140.0);
                                                                                        let v1136 = constructor_band(ctx, v2.0, v104.1, v140.1);
                                                                                        let v1137 = constructor_band(ctx, v2.0, v673, v1136);
                                                                                        // Rule at src/opts/cprop.isle line 321.
                                                                                        returns.extend(Some(v1137));
                                                                                        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 v263 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v140.1, &mut v263);
                                                                        let mut v263 = v263.into_context_iter();
                                                                        while let Some(v264) = v263.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v632,
                                                                                arg: v633,
                                                                            } = &v264.1 {
                                                                                if let &Opcode::Bnot = v632 {
                                                                                    if v104.1 == v633 {
                                                                                        if v2.0 == v264.0 {
                                                                                            // Rule at src/opts/bitops.isle line 474.
                                                                                            returns.extend(Some(v104.0));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let v685 = constructor_band(ctx, v2.0, v104.1, v140.1);
                                                                        let v686 = constructor_bor(ctx, v2.0, v685, v104.0);
                                                                        // Rule at src/opts/bitops.isle line 261.
                                                                        returns.extend(Some(v686));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        let v687 = constructor_band(ctx, v2.0, v140.1, v104.1);
                                                                        let v688 = constructor_bor(ctx, v2.0, v687, v104.0);
                                                                        // Rule at src/opts/bitops.isle line 262.
                                                                        returns.extend(Some(v688));
                                                                        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 v279 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v140.0, &mut v279);
                                                                        let mut v279 = v279.into_context_iter();
                                                                        while let Some(v280) = v279.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v635,
                                                                                arg: v636,
                                                                            } = &v280.1 {
                                                                                if let &Opcode::Bnot = v635 {
                                                                                    if v104.1 == v636 {
                                                                                        if v2.0 == v280.0 {
                                                                                            // Rule at src/opts/bitops.isle line 476.
                                                                                            returns.extend(Some(v104.0));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let v679 = constructor_band(ctx, v2.0, v140.0, v104.1);
                                                                        let v680 = constructor_bor(ctx, v2.0, v679, v104.0);
                                                                        // Rule at src/opts/bitops.isle line 258.
                                                                        returns.extend(Some(v680));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        let v681 = constructor_band(ctx, v2.0, v104.1, v140.0);
                                                                        let v682 = constructor_bor(ctx, v2.0, v681, v104.0);
                                                                        // Rule at src/opts/bitops.isle line 259.
                                                                        returns.extend(Some(v682));
                                                                        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 v263 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v140.1, &mut v263);
                                                                        let mut v263 = v263.into_context_iter();
                                                                        while let Some(v264) = v263.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v632,
                                                                                arg: v633,
                                                                            } = &v264.1 {
                                                                                if let &Opcode::Bnot = v632 {
                                                                                    if v104.0 == v633 {
                                                                                        if v2.0 == v264.0 {
                                                                                            // Rule at src/opts/bitops.isle line 478.
                                                                                            returns.extend(Some(v104.1));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let v677 = constructor_band(ctx, v2.0, v104.0, v140.1);
                                                                        let v678 = constructor_bor(ctx, v2.0, v677, v104.1);
                                                                        // Rule at src/opts/bitops.isle line 257.
                                                                        returns.extend(Some(v678));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        let v683 = constructor_band(ctx, v2.0, v140.1, v104.0);
                                                                        let v684 = constructor_bor(ctx, v2.0, v683, v104.1);
                                                                        // Rule at src/opts/bitops.isle line 260.
                                                                        returns.extend(Some(v684));
                                                                        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 v279 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v140.0, &mut v279);
                                                                        let mut v279 = v279.into_context_iter();
                                                                        while let Some(v280) = v279.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v635,
                                                                                arg: v636,
                                                                            } = &v280.1 {
                                                                                if let &Opcode::Bnot = v635 {
                                                                                    if v104.0 == v636 {
                                                                                        if v2.0 == v280.0 {
                                                                                            // Rule at src/opts/bitops.isle line 480.
                                                                                            returns.extend(Some(v104.1));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let v673 = constructor_band(ctx, v2.0, v104.0, v140.0);
                                                                        let v674 = constructor_bor(ctx, v2.0, v673, v104.1);
                                                                        // Rule at src/opts/bitops.isle line 255.
                                                                        returns.extend(Some(v674));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        let v675 = constructor_band(ctx, v2.0, v140.0, v104.0);
                                                                        let v676 = constructor_bor(ctx, v2.0, v675, v104.1);
                                                                        // Rule at src/opts/bitops.isle line 256.
                                                                        returns.extend(Some(v676));
                                                                        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 v654 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v30, &mut v654);
                                                                    let mut v654 = v654.into_context_iter();
                                                                    while let Some(v655) = v654.next(ctx) {
                                                                        if let &InstructionData::Binary {
                                                                            opcode: ref v658,
                                                                            args: ref v659,
                                                                        } = &v655.1 {
                                                                            match v658 {
                                                                                &Opcode::Band => {
                                                                                    if v2.0 == v655.0 {
                                                                                        let v140 = C::unpack_value_array_2(ctx, v139);
                                                                                        let mut v263 = C::inst_data_value_etor_returns::default();
                                                                                        C::inst_data_value_etor(ctx, v140.1, &mut v263);
                                                                                        let mut v263 = v263.into_context_iter();
                                                                                        while let Some(v264) = v263.next(ctx) {
                                                                                            if let &InstructionData::Unary {
                                                                                                opcode: ref v632,
                                                                                                arg: v633,
                                                                                            } = &v264.1 {
                                                                                                if let &Opcode::Bnot = v632 {
                                                                                                    if v2.0 == v264.0 {
                                                                                                        let v660 = C::unpack_value_array_2(ctx, v659);
                                                                                                        if v140.0 == v660.0 {
                                                                                                            if v633 == v660.1 {
                                                                                                                let v743 = constructor_bnot(ctx, v2.0, v660.1);
                                                                                                                // Rule at src/opts/bitops.isle line 668.
                                                                                                                returns.extend(Some(v743));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                        if v633 == v660.0 {
                                                                                                            if v140.0 == v660.1 {
                                                                                                                let v739 = constructor_bnot(ctx, v2.0, v660.0);
                                                                                                                // Rule at src/opts/bitops.isle line 666.
                                                                                                                returns.extend(Some(v739));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                        let mut v279 = C::inst_data_value_etor_returns::default();
                                                                                        C::inst_data_value_etor(ctx, v140.0, &mut v279);
                                                                                        let mut v279 = v279.into_context_iter();
                                                                                        while let Some(v280) = v279.next(ctx) {
                                                                                            if let &InstructionData::Unary {
                                                                                                opcode: ref v635,
                                                                                                arg: v636,
                                                                                            } = &v280.1 {
                                                                                                if let &Opcode::Bnot = v635 {
                                                                                                    if v2.0 == v280.0 {
                                                                                                        let v660 = C::unpack_value_array_2(ctx, v659);
                                                                                                        if v140.1 == v660.0 {
                                                                                                            if v636 == v660.1 {
                                                                                                                let v743 = constructor_bnot(ctx, v2.0, v660.1);
                                                                                                                // Rule at src/opts/bitops.isle line 664.
                                                                                                                returns.extend(Some(v743));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                        if v636 == v660.0 {
                                                                                                            if v140.1 == v660.1 {
                                                                                                                let v739 = constructor_bnot(ctx, v2.0, v660.0);
                                                                                                                // Rule at src/opts/bitops.isle line 662.
                                                                                                                returns.extend(Some(v739));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                                &Opcode::Bxor => {
                                                                                    if v2.0 == v655.0 {
                                                                                        let v140 = C::unpack_value_array_2(ctx, v139);
                                                                                        let v660 = C::unpack_value_array_2(ctx, v659);
                                                                                        if v140.0 == v660.0 {
                                                                                            if v140.1 == v660.1 {
                                                                                                let v887 = constructor_band(ctx, v2.0, v660.0, v660.1);
                                                                                                // Rule at src/opts/bitops.isle line 581.
                                                                                                returns.extend(Some(v887));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v888 = constructor_band(ctx, v2.0, v660.1, v660.0);
                                                                                                // Rule at src/opts/bitops.isle line 587.
                                                                                                returns.extend(Some(v888));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                        if v140.0 == v660.1 {
                                                                                            if v140.1 == v660.0 {
                                                                                                let v888 = constructor_band(ctx, v2.0, v660.1, v660.0);
                                                                                                // Rule at src/opts/bitops.isle line 583.
                                                                                                returns.extend(Some(v888));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v887 = constructor_band(ctx, v2.0, v660.0, v660.1);
                                                                                                // Rule at src/opts/bitops.isle line 585.
                                                                                                returns.extend(Some(v887));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                                _ => {}
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let v140 = C::unpack_value_array_2(ctx, v139);
                                                let mut v263 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v140.1, &mut v263);
                                                let mut v263 = v263.into_context_iter();
                                                while let Some(v264) = v263.next(ctx) {
                                                    match &v264.1 {
                                                        &InstructionData::Binary {
                                                            opcode: ref v267,
                                                            args: ref v268,
                                                        } => {
                                                            if let &Opcode::Band = v267 {
                                                                if v2.0 == v264.0 {
                                                                    let v269 = C::unpack_value_array_2(ctx, v268);
                                                                    if v7.0 == v269.0 {
                                                                        let v853 = constructor_bor(ctx, v2.0, v140.0, v269.1);
                                                                        let v854 = constructor_band(ctx, v2.0, v853, v7.0);
                                                                        // Rule at src/opts/bitops.isle line 507.
                                                                        returns.extend(Some(v854));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v7.0 == v269.1 {
                                                                        let v861 = constructor_bor(ctx, v2.0, v140.0, v269.0);
                                                                        let v862 = constructor_band(ctx, v2.0, v861, v7.0);
                                                                        // Rule at src/opts/bitops.isle line 511.
                                                                        returns.extend(Some(v862));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v632,
                                                            arg: v633,
                                                        } => {
                                                            if let &Opcode::Bnot = v632 {
                                                                if v7.0 == v633 {
                                                                    if v2.0 == v264.0 {
                                                                        let v869 = constructor_band(ctx, v2.0, v7.0, v140.0);
                                                                        // Rule at src/opts/bitops.isle line 528.
                                                                        returns.extend(Some(v869));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let mut v279 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v140.0, &mut v279);
                                                let mut v279 = v279.into_context_iter();
                                                while let Some(v280) = v279.next(ctx) {
                                                    match &v280.1 {
                                                        &InstructionData::Binary {
                                                            opcode: ref v283,
                                                            args: ref v284,
                                                        } => {
                                                            if let &Opcode::Band = v283 {
                                                                if v2.0 == v280.0 {
                                                                    let v285 = C::unpack_value_array_2(ctx, v284);
                                                                    if v7.0 == v285.0 {
                                                                        let v857 = constructor_bor(ctx, v2.0, v140.1, v285.1);
                                                                        let v858 = constructor_band(ctx, v2.0, v857, v7.0);
                                                                        // Rule at src/opts/bitops.isle line 509.
                                                                        returns.extend(Some(v858));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v7.0 == v285.1 {
                                                                        let v865 = constructor_bor(ctx, v2.0, v140.1, v285.0);
                                                                        let v866 = constructor_band(ctx, v2.0, v865, v7.0);
                                                                        // Rule at src/opts/bitops.isle line 513.
                                                                        returns.extend(Some(v866));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v635,
                                                            arg: v636,
                                                        } => {
                                                            if let &Opcode::Bnot = v635 {
                                                                if v7.0 == v636 {
                                                                    if v2.0 == v280.0 {
                                                                        let v628 = constructor_band(ctx, v2.0, v7.0, v140.1);
                                                                        // Rule at src/opts/bitops.isle line 526.
                                                                        returns.extend(Some(v628));
                                                                        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 v273,
                                                                            args: ref v274,
                                                                        } = &v115.1 {
                                                                            if let &Opcode::Bxor = v273 {
                                                                                if v2.0 == v115.0 {
                                                                                    let v275 = C::unpack_value_array_2(ctx, v274);
                                                                                    if v140.1 == v275.0 {
                                                                                        let v902 = constructor_bxor(ctx, v2.0, v104.0, v275.0);
                                                                                        let v903 = constructor_bnot(ctx, v2.0, v275.1);
                                                                                        let v904 = constructor_band(ctx, v2.0, v902, v903);
                                                                                        // Rule at src/opts/bitops.isle line 627.
                                                                                        returns.extend(Some(v904));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v140.1 == v275.1 {
                                                                                        let v912 = constructor_bxor(ctx, v2.0, v104.0, v275.1);
                                                                                        let v913 = constructor_bnot(ctx, v2.0, v275.0);
                                                                                        let v914 = constructor_band(ctx, v2.0, v912, v913);
                                                                                        // Rule at src/opts/bitops.isle line 631.
                                                                                        returns.extend(Some(v914));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    let mut v263 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v140.1, &mut v263);
                                                                    let mut v263 = v263.into_context_iter();
                                                                    while let Some(v264) = v263.next(ctx) {
                                                                        if let &InstructionData::Binary {
                                                                            opcode: ref v267,
                                                                            args: ref v268,
                                                                        } = &v264.1 {
                                                                            if let &Opcode::Bxor = v267 {
                                                                                if v2.0 == v264.0 {
                                                                                    let v269 = C::unpack_value_array_2(ctx, v268);
                                                                                    if v104.1 == v269.0 {
                                                                                        let v243 = constructor_bxor(ctx, v2.0, v104.0, v104.1);
                                                                                        let v900 = constructor_bnot(ctx, v2.0, v269.1);
                                                                                        let v901 = constructor_band(ctx, v2.0, v243, v900);
                                                                                        // Rule at src/opts/bitops.isle line 626.
                                                                                        returns.extend(Some(v901));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v104.1 == v269.1 {
                                                                                        let v243 = constructor_bxor(ctx, v2.0, v104.0, v104.1);
                                                                                        let v910 = constructor_bnot(ctx, v2.0, v269.0);
                                                                                        let v911 = constructor_band(ctx, v2.0, v243, v910);
                                                                                        // Rule at src/opts/bitops.isle line 630.
                                                                                        returns.extend(Some(v911));
                                                                                        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 v273,
                                                                            args: ref v274,
                                                                        } = &v115.1 {
                                                                            if let &Opcode::Bxor = v273 {
                                                                                if v2.0 == v115.0 {
                                                                                    let v275 = C::unpack_value_array_2(ctx, v274);
                                                                                    if v140.0 == v275.0 {
                                                                                        let v902 = constructor_bxor(ctx, v2.0, v104.0, v275.0);
                                                                                        let v903 = constructor_bnot(ctx, v2.0, v275.1);
                                                                                        let v904 = constructor_band(ctx, v2.0, v902, v903);
                                                                                        // Rule at src/opts/bitops.isle line 635.
                                                                                        returns.extend(Some(v904));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v140.0 == v275.1 {
                                                                                        let v912 = constructor_bxor(ctx, v2.0, v104.0, v275.1);
                                                                                        let v913 = constructor_bnot(ctx, v2.0, v275.0);
                                                                                        let v914 = constructor_band(ctx, v2.0, v912, v913);
                                                                                        // Rule at src/opts/bitops.isle line 639.
                                                                                        returns.extend(Some(v914));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    let mut v279 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v140.0, &mut v279);
                                                                    let mut v279 = v279.into_context_iter();
                                                                    while let Some(v280) = v279.next(ctx) {
                                                                        if let &InstructionData::Binary {
                                                                            opcode: ref v283,
                                                                            args: ref v284,
                                                                        } = &v280.1 {
                                                                            if let &Opcode::Bxor = v283 {
                                                                                if v2.0 == v280.0 {
                                                                                    let v285 = C::unpack_value_array_2(ctx, v284);
                                                                                    if v104.1 == v285.0 {
                                                                                        let v243 = constructor_bxor(ctx, v2.0, v104.0, v104.1);
                                                                                        let v895 = constructor_bnot(ctx, v2.0, v285.1);
                                                                                        let v896 = constructor_band(ctx, v2.0, v243, v895);
                                                                                        // Rule at src/opts/bitops.isle line 624.
                                                                                        returns.extend(Some(v896));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v104.1 == v285.1 {
                                                                                        let v243 = constructor_bxor(ctx, v2.0, v104.0, v104.1);
                                                                                        let v905 = constructor_bnot(ctx, v2.0, v285.0);
                                                                                        let v906 = constructor_band(ctx, v2.0, v243, v905);
                                                                                        // Rule at src/opts/bitops.isle line 628.
                                                                                        returns.extend(Some(v906));
                                                                                        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 v289,
                                                                            args: ref v290,
                                                                        } = &v108.1 {
                                                                            if let &Opcode::Bxor = v289 {
                                                                                if v2.0 == v108.0 {
                                                                                    let v291 = C::unpack_value_array_2(ctx, v290);
                                                                                    if v140.1 == v291.0 {
                                                                                        let v897 = constructor_bxor(ctx, v2.0, v104.1, v291.0);
                                                                                        let v898 = constructor_bnot(ctx, v2.0, v291.1);
                                                                                        let v899 = constructor_band(ctx, v2.0, v897, v898);
                                                                                        // Rule at src/opts/bitops.isle line 625.
                                                                                        returns.extend(Some(v899));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v140.1 == v291.1 {
                                                                                        let v907 = constructor_bxor(ctx, v2.0, v104.1, v291.1);
                                                                                        let v908 = constructor_bnot(ctx, v2.0, v291.0);
                                                                                        let v909 = constructor_band(ctx, v2.0, v907, v908);
                                                                                        // Rule at src/opts/bitops.isle line 629.
                                                                                        returns.extend(Some(v909));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    let mut v263 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v140.1, &mut v263);
                                                                    let mut v263 = v263.into_context_iter();
                                                                    while let Some(v264) = v263.next(ctx) {
                                                                        if let &InstructionData::Binary {
                                                                            opcode: ref v267,
                                                                            args: ref v268,
                                                                        } = &v264.1 {
                                                                            if let &Opcode::Bxor = v267 {
                                                                                if v2.0 == v264.0 {
                                                                                    let v269 = C::unpack_value_array_2(ctx, v268);
                                                                                    if v104.0 == v269.0 {
                                                                                        let v244 = constructor_bxor(ctx, v2.0, v104.1, v104.0);
                                                                                        let v900 = constructor_bnot(ctx, v2.0, v269.1);
                                                                                        let v916 = constructor_band(ctx, v2.0, v244, v900);
                                                                                        // Rule at src/opts/bitops.isle line 634.
                                                                                        returns.extend(Some(v916));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v104.0 == v269.1 {
                                                                                        let v244 = constructor_bxor(ctx, v2.0, v104.1, v104.0);
                                                                                        let v910 = constructor_bnot(ctx, v2.0, v269.0);
                                                                                        let v918 = constructor_band(ctx, v2.0, v244, v910);
                                                                                        // Rule at src/opts/bitops.isle line 638.
                                                                                        returns.extend(Some(v918));
                                                                                        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 v289,
                                                                            args: ref v290,
                                                                        } = &v108.1 {
                                                                            if let &Opcode::Bxor = v289 {
                                                                                if v2.0 == v108.0 {
                                                                                    let v291 = C::unpack_value_array_2(ctx, v290);
                                                                                    if v140.0 == v291.0 {
                                                                                        let v897 = constructor_bxor(ctx, v2.0, v104.1, v291.0);
                                                                                        let v898 = constructor_bnot(ctx, v2.0, v291.1);
                                                                                        let v899 = constructor_band(ctx, v2.0, v897, v898);
                                                                                        // Rule at src/opts/bitops.isle line 633.
                                                                                        returns.extend(Some(v899));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v140.0 == v291.1 {
                                                                                        let v907 = constructor_bxor(ctx, v2.0, v104.1, v291.1);
                                                                                        let v908 = constructor_bnot(ctx, v2.0, v291.0);
                                                                                        let v909 = constructor_band(ctx, v2.0, v907, v908);
                                                                                        // Rule at src/opts/bitops.isle line 637.
                                                                                        returns.extend(Some(v909));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    let mut v279 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v140.0, &mut v279);
                                                                    let mut v279 = v279.into_context_iter();
                                                                    while let Some(v280) = v279.next(ctx) {
                                                                        if let &InstructionData::Binary {
                                                                            opcode: ref v283,
                                                                            args: ref v284,
                                                                        } = &v280.1 {
                                                                            if let &Opcode::Bxor = v283 {
                                                                                if v2.0 == v280.0 {
                                                                                    let v285 = C::unpack_value_array_2(ctx, v284);
                                                                                    if v104.0 == v285.0 {
                                                                                        let v244 = constructor_bxor(ctx, v2.0, v104.1, v104.0);
                                                                                        let v895 = constructor_bnot(ctx, v2.0, v285.1);
                                                                                        let v915 = constructor_band(ctx, v2.0, v244, v895);
                                                                                        // Rule at src/opts/bitops.isle line 632.
                                                                                        returns.extend(Some(v915));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v104.0 == v285.1 {
                                                                                        let v244 = constructor_bxor(ctx, v2.0, v104.1, v104.0);
                                                                                        let v905 = constructor_bnot(ctx, v2.0, v285.0);
                                                                                        let v917 = constructor_band(ctx, v2.0, v244, v905);
                                                                                        // Rule at src/opts/bitops.isle line 636.
                                                                                        returns.extend(Some(v917));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                let v140 = C::unpack_value_array_2(ctx, v139);
                                                let mut v263 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v140.1, &mut v263);
                                                let mut v263 = v263.into_context_iter();
                                                while let Some(v264) = v263.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v632,
                                                        arg: v633,
                                                    } = &v264.1 {
                                                        if let &Opcode::Bnot = v632 {
                                                            if v2.0 == v264.0 {
                                                                if v7.0 == v633 {
                                                                    let v869 = constructor_band(ctx, v2.0, v7.0, v140.0);
                                                                    // Rule at src/opts/bitops.isle line 610.
                                                                    returns.extend(Some(v869));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v7.0 == v140.0 {
                                                                    let v634 = constructor_band(ctx, v2.0, v7.0, v633);
                                                                    // Rule at src/opts/bitops.isle line 200.
                                                                    returns.extend(Some(v634));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                let mut v279 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v140.0, &mut v279);
                                                let mut v279 = v279.into_context_iter();
                                                while let Some(v280) = v279.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v635,
                                                        arg: v636,
                                                    } = &v280.1 {
                                                        if let &Opcode::Bnot = v635 {
                                                            if v2.0 == v280.0 {
                                                                if v7.0 == v140.1 {
                                                                    let v637 = constructor_band(ctx, v2.0, v7.0, v636);
                                                                    // Rule at src/opts/bitops.isle line 201.
                                                                    returns.extend(Some(v637));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v7.0 == v636 {
                                                                    let v628 = constructor_band(ctx, v2.0, v7.0, v140.1);
                                                                    // Rule at src/opts/bitops.isle line 608.
                                                                    returns.extend(Some(v628));
                                                                    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 v673 = constructor_band(ctx, v2.0, v104.0, v140.0);
                                                                    let v1909 = constructor_ishl(ctx, v2.0, v673, v104.1);
                                                                    // Rule at src/opts/shifts.isle line 312.
                                                                    returns.extend(Some(v1909));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::IntCompare {
                                    opcode: ref v760,
                                    args: ref v761,
                                    cond: ref v762,
                                } => {
                                    if let &Opcode::Icmp = v760 {
                                        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 v754,
                                                args: ref v755,
                                                cond: ref v756,
                                            } = &v19.1 {
                                                if let &Opcode::Icmp = v754 {
                                                    if v11.0 == v19.0 {
                                                        match v756 {
                                                            &IntCC::NotEqual => {
                                                                match v762 {
                                                                    &IntCC::UnsignedGreaterThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v757 = C::unpack_value_array_2(ctx, v755);
                                                                            let v763 = C::unpack_value_array_2(ctx, v761);
                                                                            if v757.0 == v763.1 {
                                                                                let mut v1550 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v757.1, &mut v1550);
                                                                                let mut v1550 = v1550.into_context_iter();
                                                                                while let Some(v1551) = v1550.next(ctx) {
                                                                                    let v1552 = C::iconst_sextend_etor(ctx, v1551);
                                                                                    if let Some(v1553) = v1552 {
                                                                                        if v1553.1 == -1_i64 {
                                                                                            let v1578 = constructor_ult(ctx, v2.0, v757.0, v763.0);
                                                                                            // Rule at src/opts/icmp.isle line 358.
                                                                                            returns.extend(Some(v1578));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            if v757.1 == v763.1 {
                                                                                let mut v1563 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v757.0, &mut v1563);
                                                                                let mut v1563 = v1563.into_context_iter();
                                                                                while let Some(v1564) = v1563.next(ctx) {
                                                                                    let v1565 = C::iconst_sextend_etor(ctx, v1564);
                                                                                    if let Some(v1566) = v1565 {
                                                                                        if v1566.1 == -1_i64 {
                                                                                            let v1580 = constructor_ult(ctx, v2.0, v757.1, v763.0);
                                                                                            // Rule at src/opts/icmp.isle line 364.
                                                                                            returns.extend(Some(v1580));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v757 = C::unpack_value_array_2(ctx, v755);
                                                                            let v763 = C::unpack_value_array_2(ctx, v761);
                                                                            if v757.0 == v763.0 {
                                                                                let mut v1550 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v757.1, &mut v1550);
                                                                                let mut v1550 = v1550.into_context_iter();
                                                                                while let Some(v1551) = v1550.next(ctx) {
                                                                                    let v1552 = C::iconst_sextend_etor(ctx, v1551);
                                                                                    if let Some(v1553) = v1552 {
                                                                                        if v1553.1 == -1_i64 {
                                                                                            let v1579 = constructor_ult(ctx, v2.0, v757.0, v763.1);
                                                                                            // Rule at src/opts/icmp.isle line 361.
                                                                                            returns.extend(Some(v1579));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            if v757.1 == v763.0 {
                                                                                let mut v1563 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v757.0, &mut v1563);
                                                                                let mut v1563 = v1563.into_context_iter();
                                                                                while let Some(v1564) = v1563.next(ctx) {
                                                                                    let v1565 = C::iconst_sextend_etor(ctx, v1564);
                                                                                    if let Some(v1566) = v1565 {
                                                                                        if v1566.1 == -1_i64 {
                                                                                            let v1581 = constructor_ult(ctx, v2.0, v757.1, v763.1);
                                                                                            // Rule at src/opts/icmp.isle line 367.
                                                                                            returns.extend(Some(v1581));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                            &IntCC::SignedGreaterThan => {
                                                                match v762 {
                                                                    &IntCC::SignedLessThan => {
                                                                        let v348 = C::ty_int_vec128(ctx, v2.0);
                                                                        if let Some(v349) = v348 {
                                                                            if v11.0 == v349 {
                                                                                let v757 = C::unpack_value_array_2(ctx, v755);
                                                                                let v763 = C::unpack_value_array_2(ctx, v761);
                                                                                if v757.0 == v763.0 {
                                                                                    if v757.1 == v763.1 {
                                                                                        let v352 = constructor_iconst_u(ctx, v349, 0x0_u64);
                                                                                        // Rule at src/opts/icmp.isle line 319.
                                                                                        returns.extend(Some(v352));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v757 = C::unpack_value_array_2(ctx, v755);
                                                                            let v763 = C::unpack_value_array_2(ctx, v761);
                                                                            if v757.0 == v763.0 {
                                                                                let mut v1550 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v757.1, &mut v1550);
                                                                                let mut v1550 = v1550.into_context_iter();
                                                                                while let Some(v1551) = v1550.next(ctx) {
                                                                                    let v1552 = C::iconst_sextend_etor(ctx, v1551);
                                                                                    if let Some(v1553) = v1552 {
                                                                                        let v1562 = C::i64_gt_eq(ctx, v1553.1, 0_i64);
                                                                                        if v1562 == true {
                                                                                            let mut v1556 = C::inst_data_value_tupled_etor_returns::default();
                                                                                            C::inst_data_value_tupled_etor(ctx, v763.1, &mut v1556);
                                                                                            let mut v1556 = v1556.into_context_iter();
                                                                                            while let Some(v1557) = v1556.next(ctx) {
                                                                                                let v1558 = C::iconst_sextend_etor(ctx, v1557);
                                                                                                if let Some(v1559) = v1558 {
                                                                                                    if v1553.1 == v1559.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 v757.1 == v763.1 {
                                                                                let mut v1563 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v757.0, &mut v1563);
                                                                                let mut v1563 = v1563.into_context_iter();
                                                                                while let Some(v1564) = v1563.next(ctx) {
                                                                                    let v1565 = C::iconst_sextend_etor(ctx, v1564);
                                                                                    if let Some(v1566) = v1565 {
                                                                                        let v1575 = C::i64_lt(ctx, v1566.1, 0_i64);
                                                                                        if v1575 == true {
                                                                                            let mut v1569 = C::inst_data_value_tupled_etor_returns::default();
                                                                                            C::inst_data_value_tupled_etor(ctx, v763.0, &mut v1569);
                                                                                            let mut v1569 = v1569.into_context_iter();
                                                                                            while let Some(v1570) = v1569.next(ctx) {
                                                                                                let v1571 = C::iconst_sextend_etor(ctx, v1570);
                                                                                                if let Some(v1572) = v1571 {
                                                                                                    if v1566.1 == v1572.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 v762 {
                                                                    &IntCC::SignedGreaterThan => {
                                                                        let v348 = C::ty_int_vec128(ctx, v2.0);
                                                                        if let Some(v349) = v348 {
                                                                            if v11.0 == v349 {
                                                                                let v757 = C::unpack_value_array_2(ctx, v755);
                                                                                let v763 = C::unpack_value_array_2(ctx, v761);
                                                                                if v757.0 == v763.0 {
                                                                                    if v757.1 == v763.1 {
                                                                                        let v352 = constructor_iconst_u(ctx, v349, 0x0_u64);
                                                                                        // Rule at src/opts/icmp.isle line 320.
                                                                                        returns.extend(Some(v352));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedGreaterThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v757 = C::unpack_value_array_2(ctx, v755);
                                                                            let v763 = C::unpack_value_array_2(ctx, v761);
                                                                            if v757.0 == v763.0 {
                                                                                let mut v1550 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v757.1, &mut v1550);
                                                                                let mut v1550 = v1550.into_context_iter();
                                                                                while let Some(v1551) = v1550.next(ctx) {
                                                                                    let v1552 = C::iconst_sextend_etor(ctx, v1551);
                                                                                    if let Some(v1553) = v1552 {
                                                                                        let v1576 = C::i64_lt(ctx, v1553.1, 0_i64);
                                                                                        if v1576 == true {
                                                                                            let mut v1556 = C::inst_data_value_tupled_etor_returns::default();
                                                                                            C::inst_data_value_tupled_etor(ctx, v763.1, &mut v1556);
                                                                                            let mut v1556 = v1556.into_context_iter();
                                                                                            while let Some(v1557) = v1556.next(ctx) {
                                                                                                let v1558 = C::iconst_sextend_etor(ctx, v1557);
                                                                                                if let Some(v1559) = v1558 {
                                                                                                    if v1553.1 == v1559.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 v757.1 == v763.1 {
                                                                                let mut v1563 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v757.0, &mut v1563);
                                                                                let mut v1563 = v1563.into_context_iter();
                                                                                while let Some(v1564) = v1563.next(ctx) {
                                                                                    let v1565 = C::iconst_sextend_etor(ctx, v1564);
                                                                                    if let Some(v1566) = v1565 {
                                                                                        let v1577 = C::i64_gt_eq(ctx, v1566.1, 0_i64);
                                                                                        if v1577 == true {
                                                                                            let mut v1569 = C::inst_data_value_tupled_etor_returns::default();
                                                                                            C::inst_data_value_tupled_etor(ctx, v763.0, &mut v1569);
                                                                                            let mut v1569 = v1569.into_context_iter();
                                                                                            while let Some(v1570) = v1569.next(ctx) {
                                                                                                let v1571 = C::iconst_sextend_etor(ctx, v1570);
                                                                                                if let Some(v1572) = v1571 {
                                                                                                    if v1566.1 == v1572.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 v762 {
                                                                    &IntCC::NotEqual => {
                                                                        if v2.0 == v11.0 {
                                                                            let v757 = C::unpack_value_array_2(ctx, v755);
                                                                            let v763 = C::unpack_value_array_2(ctx, v761);
                                                                            if v757.1 == v763.0 {
                                                                                let mut v1556 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v763.1, &mut v1556);
                                                                                let mut v1556 = v1556.into_context_iter();
                                                                                while let Some(v1557) = v1556.next(ctx) {
                                                                                    let v1558 = C::iconst_sextend_etor(ctx, v1557);
                                                                                    if let Some(v1559) = v1558 {
                                                                                        if v1559.1 == -1_i64 {
                                                                                            let v1582 = constructor_ult(ctx, v2.0, v757.1, v757.0);
                                                                                            // Rule at src/opts/icmp.isle line 370.
                                                                                            returns.extend(Some(v1582));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            if v757.1 == v763.1 {
                                                                                let mut v1569 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v763.0, &mut v1569);
                                                                                let mut v1569 = v1569.into_context_iter();
                                                                                while let Some(v1570) = v1569.next(ctx) {
                                                                                    let v1571 = C::iconst_sextend_etor(ctx, v1570);
                                                                                    if let Some(v1572) = v1571 {
                                                                                        if v1572.1 == -1_i64 {
                                                                                            let v1582 = constructor_ult(ctx, v2.0, v757.1, v757.0);
                                                                                            // Rule at src/opts/icmp.isle line 373.
                                                                                            returns.extend(Some(v1582));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedLessThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v757 = C::unpack_value_array_2(ctx, v755);
                                                                            let v763 = C::unpack_value_array_2(ctx, v761);
                                                                            if v757.0 == v763.0 {
                                                                                let mut v1550 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v757.1, &mut v1550);
                                                                                let mut v1550 = v1550.into_context_iter();
                                                                                while let Some(v1551) = v1550.next(ctx) {
                                                                                    let v1552 = C::iconst_sextend_etor(ctx, v1551);
                                                                                    if let Some(v1553) = v1552 {
                                                                                        let v1576 = C::i64_lt(ctx, v1553.1, 0_i64);
                                                                                        if v1576 == true {
                                                                                            let mut v1556 = C::inst_data_value_tupled_etor_returns::default();
                                                                                            C::inst_data_value_tupled_etor(ctx, v763.1, &mut v1556);
                                                                                            let mut v1556 = v1556.into_context_iter();
                                                                                            while let Some(v1557) = v1556.next(ctx) {
                                                                                                let v1558 = C::iconst_sextend_etor(ctx, v1557);
                                                                                                if let Some(v1559) = v1558 {
                                                                                                    if v1553.1 == v1559.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 v757.1 == v763.1 {
                                                                                let mut v1563 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v757.0, &mut v1563);
                                                                                let mut v1563 = v1563.into_context_iter();
                                                                                while let Some(v1564) = v1563.next(ctx) {
                                                                                    let v1565 = C::iconst_sextend_etor(ctx, v1564);
                                                                                    if let Some(v1566) = v1565 {
                                                                                        let v1577 = C::i64_gt_eq(ctx, v1566.1, 0_i64);
                                                                                        if v1577 == true {
                                                                                            let mut v1569 = C::inst_data_value_tupled_etor_returns::default();
                                                                                            C::inst_data_value_tupled_etor(ctx, v763.0, &mut v1569);
                                                                                            let mut v1569 = v1569.into_context_iter();
                                                                                            while let Some(v1570) = v1569.next(ctx) {
                                                                                                let v1571 = C::iconst_sextend_etor(ctx, v1570);
                                                                                                if let Some(v1572) = v1571 {
                                                                                                    if v1566.1 == v1572.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 v348 = C::ty_int_vec128(ctx, v2.0);
                                                                        if let Some(v349) = v348 {
                                                                            if v11.0 == v349 {
                                                                                let v757 = C::unpack_value_array_2(ctx, v755);
                                                                                let v763 = C::unpack_value_array_2(ctx, v761);
                                                                                if v757.0 == v763.0 {
                                                                                    if v757.1 == v763.1 {
                                                                                        let v352 = constructor_iconst_u(ctx, v349, 0x0_u64);
                                                                                        // Rule at src/opts/icmp.isle line 321.
                                                                                        returns.extend(Some(v352));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                            &IntCC::UnsignedLessThan => {
                                                                match v762 {
                                                                    &IntCC::NotEqual => {
                                                                        if v2.0 == v11.0 {
                                                                            let v757 = C::unpack_value_array_2(ctx, v755);
                                                                            let v763 = C::unpack_value_array_2(ctx, v761);
                                                                            if v757.0 == v763.0 {
                                                                                let mut v1556 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v763.1, &mut v1556);
                                                                                let mut v1556 = v1556.into_context_iter();
                                                                                while let Some(v1557) = v1556.next(ctx) {
                                                                                    let v1558 = C::iconst_sextend_etor(ctx, v1557);
                                                                                    if let Some(v1559) = v1558 {
                                                                                        if v1559.1 == -1_i64 {
                                                                                            let v1583 = constructor_ult(ctx, v2.0, v757.0, v757.1);
                                                                                            // Rule at src/opts/icmp.isle line 376.
                                                                                            returns.extend(Some(v1583));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            if v757.0 == v763.1 {
                                                                                let mut v1569 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v763.0, &mut v1569);
                                                                                let mut v1569 = v1569.into_context_iter();
                                                                                while let Some(v1570) = v1569.next(ctx) {
                                                                                    let v1571 = C::iconst_sextend_etor(ctx, v1570);
                                                                                    if let Some(v1572) = v1571 {
                                                                                        if v1572.1 == -1_i64 {
                                                                                            let v1583 = constructor_ult(ctx, v2.0, v757.0, v757.1);
                                                                                            // Rule at src/opts/icmp.isle line 379.
                                                                                            returns.extend(Some(v1583));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedGreaterThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v757 = C::unpack_value_array_2(ctx, v755);
                                                                            let v763 = C::unpack_value_array_2(ctx, v761);
                                                                            if v757.0 == v763.0 {
                                                                                let mut v1550 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v757.1, &mut v1550);
                                                                                let mut v1550 = v1550.into_context_iter();
                                                                                while let Some(v1551) = v1550.next(ctx) {
                                                                                    let v1552 = C::iconst_sextend_etor(ctx, v1551);
                                                                                    if let Some(v1553) = v1552 {
                                                                                        let v1562 = C::i64_gt_eq(ctx, v1553.1, 0_i64);
                                                                                        if v1562 == true {
                                                                                            let mut v1556 = C::inst_data_value_tupled_etor_returns::default();
                                                                                            C::inst_data_value_tupled_etor(ctx, v763.1, &mut v1556);
                                                                                            let mut v1556 = v1556.into_context_iter();
                                                                                            while let Some(v1557) = v1556.next(ctx) {
                                                                                                let v1558 = C::iconst_sextend_etor(ctx, v1557);
                                                                                                if let Some(v1559) = v1558 {
                                                                                                    if v1553.1 == v1559.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 v757.1 == v763.1 {
                                                                                let mut v1563 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v757.0, &mut v1563);
                                                                                let mut v1563 = v1563.into_context_iter();
                                                                                while let Some(v1564) = v1563.next(ctx) {
                                                                                    let v1565 = C::iconst_sextend_etor(ctx, v1564);
                                                                                    if let Some(v1566) = v1565 {
                                                                                        let v1575 = C::i64_lt(ctx, v1566.1, 0_i64);
                                                                                        if v1575 == true {
                                                                                            let mut v1569 = C::inst_data_value_tupled_etor_returns::default();
                                                                                            C::inst_data_value_tupled_etor(ctx, v763.0, &mut v1569);
                                                                                            let mut v1569 = v1569.into_context_iter();
                                                                                            while let Some(v1570) = v1569.next(ctx) {
                                                                                                let v1571 = C::iconst_sextend_etor(ctx, v1570);
                                                                                                if let Some(v1572) = v1571 {
                                                                                                    if v1566.1 == v1572.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 v348 = C::ty_int_vec128(ctx, v2.0);
                                                                        if let Some(v349) = v348 {
                                                                            if v11.0 == v349 {
                                                                                let v757 = C::unpack_value_array_2(ctx, v755);
                                                                                let v763 = C::unpack_value_array_2(ctx, v761);
                                                                                if v757.0 == v763.0 {
                                                                                    if v757.1 == v763.1 {
                                                                                        let v352 = constructor_iconst_u(ctx, v349, 0x0_u64);
                                                                                        // Rule at src/opts/icmp.isle line 322.
                                                                                        returns.extend(Some(v352));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                        let v339 = C::fits_in_64(ctx, v2.0);
                                                        if let Some(v340) = v339 {
                                                            if v11.0 == v340 {
                                                                let v1470 = constructor_intcc_comparable(ctx, v756, v762);
                                                                if let Some(v1471) = v1470 {
                                                                    let v757 = C::unpack_value_array_2(ctx, v755);
                                                                    let v763 = C::unpack_value_array_2(ctx, v761);
                                                                    if v757.0 == v763.0 {
                                                                        if v757.1 == v763.1 {
                                                                            let v1472 = constructor_decompose_intcc(ctx, v756);
                                                                            let v1473 = constructor_decompose_intcc(ctx, v762);
                                                                            let v1474 = C::u64_and(ctx, v1472, v1473);
                                                                            let v1475 = constructor_compose_icmp(ctx, v340, v1474, v1471, v757.0, v757.1);
                                                                            // Rule at src/opts/icmp.isle line 179.
                                                                            returns.extend(Some(v1475));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v26,
                                    arg: v27,
                                } => {
                                    match v26 {
                                        &Opcode::Splat => {
                                            let v1990 = C::ty_vector_not_float(ctx, v2.0);
                                            if let Some(v1991) = v1990 {
                                                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 v1854 = C::lane_type(ctx, v2.0);
                                                                    let v1992 = constructor_band(ctx, v1854, v30, v27);
                                                                    let v1993 = constructor_splat(ctx, v2.0, v1992);
                                                                    // Rule at src/opts/vector.isle line 14.
                                                                    returns.extend(Some(v1993));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Bnot => {
                                            if v2.0 == v11.0 {
                                                let mut v644 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v27, &mut v644);
                                                let mut v644 = v644.into_context_iter();
                                                while let Some(v645) = v644.next(ctx) {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v648,
                                                        args: ref v649,
                                                    } = &v645.1 {
                                                        match v648 {
                                                            &Opcode::Band => {
                                                                if v2.0 == v645.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 v650 = C::unpack_value_array_2(ctx, v649);
                                                                                                    if v104.1 == v650.0 {
                                                                                                        if v112 == v650.1 {
                                                                                                            let v930 = constructor_bnot(ctx, v2.0, v112);
                                                                                                            // Rule at src/opts/bitops.isle line 663.
                                                                                                            returns.extend(Some(v930));
                                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                        }
                                                                                                    }
                                                                                                    if v112 == v650.0 {
                                                                                                        if v104.1 == v650.1 {
                                                                                                            let v930 = constructor_bnot(ctx, v2.0, v112);
                                                                                                            // Rule at src/opts/bitops.isle line 661.
                                                                                                            returns.extend(Some(v930));
                                                                                                            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 v650 = C::unpack_value_array_2(ctx, v649);
                                                                                                    if v104.0 == v650.0 {
                                                                                                        if v119 == v650.1 {
                                                                                                            let v931 = constructor_bnot(ctx, v2.0, v119);
                                                                                                            // Rule at src/opts/bitops.isle line 667.
                                                                                                            returns.extend(Some(v931));
                                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                        }
                                                                                                    }
                                                                                                    if v119 == v650.0 {
                                                                                                        if v104.0 == v650.1 {
                                                                                                            let v931 = constructor_bnot(ctx, v2.0, v119);
                                                                                                            // Rule at src/opts/bitops.isle line 665.
                                                                                                            returns.extend(Some(v931));
                                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    let v650 = C::unpack_value_array_2(ctx, v649);
                                                                    if v7.0 == v650.0 {
                                                                        let v741 = constructor_bnot(ctx, v2.0, v650.1);
                                                                        let v747 = constructor_band(ctx, v2.0, v7.0, v741);
                                                                        // Rule at src/opts/bitops.isle line 321.
                                                                        returns.extend(Some(v747));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v7.0 == v650.1 {
                                                                        let v737 = constructor_bnot(ctx, v2.0, v650.0);
                                                                        let v745 = constructor_band(ctx, v2.0, v7.0, v737);
                                                                        // Rule at src/opts/bitops.isle line 319.
                                                                        returns.extend(Some(v745));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Bxor => {
                                                                if v2.0 == v645.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 v650 = C::unpack_value_array_2(ctx, v649);
                                                                                    if v104.0 == v650.0 {
                                                                                        if v104.1 == v650.1 {
                                                                                            let v143 = constructor_band(ctx, v2.0, v104.0, v104.1);
                                                                                            // Rule at src/opts/bitops.isle line 580.
                                                                                            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 586.
                                                                                            returns.extend(Some(v247));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                    if v104.0 == v650.1 {
                                                                                        if v104.1 == v650.0 {
                                                                                            let v143 = constructor_band(ctx, v2.0, v104.0, v104.1);
                                                                                            // Rule at src/opts/bitops.isle line 582.
                                                                                            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 584.
                                                                                            returns.extend(Some(v247));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    let v650 = C::unpack_value_array_2(ctx, v649);
                                                                    if v7.0 == v650.0 {
                                                                        let v893 = constructor_band(ctx, v2.0, v7.0, v650.1);
                                                                        // Rule at src/opts/bitops.isle line 602.
                                                                        returns.extend(Some(v893));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v7.0 == v650.1 {
                                                                        let v894 = constructor_band(ctx, v2.0, v7.0, v650.0);
                                                                        // Rule at src/opts/bitops.isle line 604.
                                                                        returns.extend(Some(v894));
                                                                        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 v705 = constructor_bor(ctx, v2.0, v30, v27);
                                                                let v706 = constructor_bnot(ctx, v2.0, v705);
                                                                // Rule at src/opts/bitops.isle line 285.
                                                                returns.extend(Some(v706));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                let v707 = constructor_bor(ctx, v2.0, v27, v30);
                                                                let v708 = constructor_bnot(ctx, v2.0, v707);
                                                                // Rule at src/opts/bitops.isle line 286.
                                                                returns.extend(Some(v708));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            let v348 = C::ty_int_vec128(ctx, v2.0);
                                            if let Some(v349) = v348 {
                                                if v11.0 == v349 {
                                                    if v7.0 == v27 {
                                                        let v352 = constructor_iconst_u(ctx, v349, 0x0_u64);
                                                        let v353 = C::subsume(ctx, v352);
                                                        // Rule at src/opts/bitops.isle line 34.
                                                        returns.extend(Some(v353));
                                                        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 v1347 = C::value_type(ctx, v30);
                                                        let v1378 = C::value_type(ctx, v27);
                                                        if v1347 == v1378 {
                                                            let v1379 = constructor_band(ctx, v1347, v30, v27);
                                                            let v1380 = constructor_uextend(ctx, v2.0, v1379);
                                                            // Rule at src/opts/extends.isle line 70.
                                                            returns.extend(Some(v1380));
                                                            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 v1058 = constructor_band(ctx, v2.0, v104.1, v7.1);
                                                                                let v1059 = constructor_band(ctx, v2.0, v104.0, v1058);
                                                                                // Rule at src/opts/cprop.isle line 219.
                                                                                returns.extend(Some(v1059));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                &InstructionData::IntCompare {
                                                    opcode: ref v754,
                                                    args: ref v755,
                                                    cond: ref v756,
                                                } => {
                                                    if let &Opcode::Icmp = v754 {
                                                        let v16 = C::u64_from_imm64(ctx, v15);
                                                        if v16 == 0x1_u64 {
                                                            let v344 = C::ty_int(ctx, v2.0);
                                                            if let Some(v345) = v344 {
                                                                // 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 v344 = C::ty_int(ctx, v2.0);
                                                                if let Some(v345) = v344 {
                                                                    let mut v654 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v30, &mut v654);
                                                                    let mut v654 = v654.into_context_iter();
                                                                    while let Some(v655) = v654.next(ctx) {
                                                                        if let &InstructionData::IntCompare {
                                                                            opcode: ref v1449,
                                                                            args: ref v1450,
                                                                            cond: ref v1451,
                                                                        } = &v655.1 {
                                                                            if let &Opcode::Icmp = v1449 {
                                                                                // Rule at src/opts/icmp.isle line 95.
                                                                                returns.extend(Some(v7.0));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            let v1347 = C::value_type(ctx, v30);
                                                            let v1348 = C::ty_mask(ctx, v1347);
                                                            let v1349 = C::u64_and(ctx, v16, v1348);
                                                            let v1350 = C::u64_eq(ctx, v1348, v1349);
                                                            if v1350 == 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 v1347 = C::value_type(ctx, v30);
                                                            let v1348 = C::ty_mask(ctx, v1347);
                                                            let v1351 = C::u64_eq(ctx, v16, v1348);
                                                            if v1351 == true {
                                                                let v1352 = constructor_uextend(ctx, v2.0, v30);
                                                                // Rule at src/opts/extends.isle line 22.
                                                                returns.extend(Some(v1352));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                &InstructionData::UnaryImm {
                                                    opcode: ref v22,
                                                    imm: v23,
                                                } => {
                                                    if let &Opcode::Iconst = v22 {
                                                        let v339 = C::fits_in_64(ctx, v2.0);
                                                        if let Some(v340) = v339 {
                                                            if v11.0 == v19.0 {
                                                                if v11.0 == v340 {
                                                                    let v969 = C::imm64_and(ctx, v340, v23, v15);
                                                                    let v970 = constructor_iconst(ctx, v340, v969);
                                                                    let v971 = C::subsume(ctx, v970);
                                                                    // Rule at src/opts/cprop.isle line 61.
                                                                    returns.extend(Some(v971));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                _ => {}
                                            }
                                        }
                                        let v16 = C::u64_from_imm64(ctx, v15);
                                        if v16 == 0x0_u64 {
                                            let v348 = C::ty_int_vec128(ctx, v2.0);
                                            if let Some(v349) = v348 {
                                                if v11.0 == v349 {
                                                    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 v1610 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 13.
                                        returns.extend(Some(v1610));
                                        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 v289,
                                                            args: ref v290,
                                                        } => {
                                                            if let &Opcode::Band = v289 {
                                                                if v2.0 == v108.0 {
                                                                    let v291 = C::unpack_value_array_2(ctx, v290);
                                                                    if v7.1 == v291.0 {
                                                                        let v855 = constructor_bor(ctx, v2.0, v104.1, v291.1);
                                                                        let v856 = constructor_band(ctx, v2.0, v855, v291.0);
                                                                        // Rule at src/opts/bitops.isle line 508.
                                                                        returns.extend(Some(v856));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v7.1 == v291.1 {
                                                                        let v863 = constructor_bor(ctx, v2.0, v104.1, v291.0);
                                                                        let v864 = constructor_band(ctx, v2.0, v863, v291.1);
                                                                        // Rule at src/opts/bitops.isle line 512.
                                                                        returns.extend(Some(v864));
                                                                        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 v868 = constructor_band(ctx, v2.0, v112, v104.1);
                                                                        // Rule at src/opts/bitops.isle line 527.
                                                                        returns.extend(Some(v868));
                                                                        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 v273,
                                                            args: ref v274,
                                                        } => {
                                                            if let &Opcode::Band = v273 {
                                                                if v2.0 == v115.0 {
                                                                    let v275 = C::unpack_value_array_2(ctx, v274);
                                                                    if v7.1 == v275.0 {
                                                                        let v851 = constructor_bor(ctx, v2.0, v104.0, v275.1);
                                                                        let v852 = constructor_band(ctx, v2.0, v851, v275.0);
                                                                        // Rule at src/opts/bitops.isle line 506.
                                                                        returns.extend(Some(v852));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v7.1 == v275.1 {
                                                                        let v859 = constructor_bor(ctx, v2.0, v104.0, v275.0);
                                                                        let v860 = constructor_band(ctx, v2.0, v859, v275.1);
                                                                        // Rule at src/opts/bitops.isle line 510.
                                                                        returns.extend(Some(v860));
                                                                        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 v870 = constructor_band(ctx, v2.0, v119, v104.0);
                                                                        // Rule at src/opts/bitops.isle line 529.
                                                                        returns.extend(Some(v870));
                                                                        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 v868 = constructor_band(ctx, v2.0, v112, v104.1);
                                                                    // Rule at src/opts/bitops.isle line 609.
                                                                    returns.extend(Some(v868));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v7.1 == v104.1 {
                                                                    let v631 = constructor_band(ctx, v2.0, v104.1, v112);
                                                                    // Rule at src/opts/bitops.isle line 199.
                                                                    returns.extend(Some(v631));
                                                                    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 v630 = constructor_band(ctx, v2.0, v104.0, v119);
                                                                    // Rule at src/opts/bitops.isle line 198.
                                                                    returns.extend(Some(v630));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v7.1 == v119 {
                                                                    let v870 = constructor_band(ctx, v2.0, v119, v104.0);
                                                                    // Rule at src/opts/bitops.isle line 611.
                                                                    returns.extend(Some(v870));
                                                                    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 v654 = C::inst_data_value_etor_returns::default();
                                            C::inst_data_value_etor(ctx, v30, &mut v654);
                                            let mut v654 = v654.into_context_iter();
                                            while let Some(v655) = v654.next(ctx) {
                                                if let &InstructionData::Binary {
                                                    opcode: ref v658,
                                                    args: ref v659,
                                                } = &v655.1 {
                                                    match v658 {
                                                        &Opcode::Band => {
                                                            if v2.0 == v655.0 {
                                                                let v660 = C::unpack_value_array_2(ctx, v659);
                                                                if v7.1 == v660.0 {
                                                                    let v743 = constructor_bnot(ctx, v2.0, v660.1);
                                                                    let v748 = constructor_band(ctx, v2.0, v660.0, v743);
                                                                    // Rule at src/opts/bitops.isle line 322.
                                                                    returns.extend(Some(v748));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v7.1 == v660.1 {
                                                                    let v739 = constructor_bnot(ctx, v2.0, v660.0);
                                                                    let v746 = constructor_band(ctx, v2.0, v660.1, v739);
                                                                    // Rule at src/opts/bitops.isle line 320.
                                                                    returns.extend(Some(v746));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                        &Opcode::Bxor => {
                                                            if v2.0 == v655.0 {
                                                                let v660 = C::unpack_value_array_2(ctx, v659);
                                                                if v7.1 == v660.0 {
                                                                    let v887 = constructor_band(ctx, v2.0, v660.0, v660.1);
                                                                    // Rule at src/opts/bitops.isle line 603.
                                                                    returns.extend(Some(v887));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v7.1 == v660.1 {
                                                                    let v888 = constructor_band(ctx, v2.0, v660.1, v660.0);
                                                                    // Rule at src/opts/bitops.isle line 605.
                                                                    returns.extend(Some(v888));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                            }
                                        }
                                        if v7.1 == v30 {
                                            let v348 = C::ty_int_vec128(ctx, v2.0);
                                            if let Some(v349) = v348 {
                                                if v19.0 == v349 {
                                                    let v352 = constructor_iconst_u(ctx, v349, 0x0_u64);
                                                    let v353 = C::subsume(ctx, v352);
                                                    // Rule at src/opts/bitops.isle line 35.
                                                    returns.extend(Some(v353));
                                                    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 v1029 = constructor_band(ctx, v2.0, v7.1, v7.0);
                                            // Rule at src/opts/cprop.isle line 161.
                                            returns.extend(Some(v1029));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        let v1610 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 11.
                                        returns.extend(Some(v1610));
                                        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,
                                                        } => {
                                                            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 {
                                                                                        let v140 = C::unpack_value_array_2(ctx, v139);
                                                                                        if v112 == v140.0 {
                                                                                            let mut v263 = C::inst_data_value_etor_returns::default();
                                                                                            C::inst_data_value_etor(ctx, v140.1, &mut v263);
                                                                                            let mut v263 = v263.into_context_iter();
                                                                                            while let Some(v264) = v263.next(ctx) {
                                                                                                if let &InstructionData::Unary {
                                                                                                    opcode: ref v632,
                                                                                                    arg: v633,
                                                                                                } = &v264.1 {
                                                                                                    if let &Opcode::Bnot = v632 {
                                                                                                        if v2.0 == v264.0 {
                                                                                                            if v104.1 == v633 {
                                                                                                                let v879 = constructor_bxor(ctx, v2.0, v112, v104.1);
                                                                                                                // Rule at src/opts/bitops.isle line 549.
                                                                                                                returns.extend(Some(v879));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                let v875 = constructor_bxor(ctx, v2.0, v104.1, v112);
                                                                                                                // Rule at src/opts/bitops.isle line 554.
                                                                                                                returns.extend(Some(v875));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                            if v104.1 == v140.1 {
                                                                                                // Rule at src/opts/bitops.isle line 471.
                                                                                                returns.extend(Some(v104.1));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                        if v112 == v140.1 {
                                                                                            let mut v279 = C::inst_data_value_etor_returns::default();
                                                                                            C::inst_data_value_etor(ctx, v140.0, &mut v279);
                                                                                            let mut v279 = v279.into_context_iter();
                                                                                            while let Some(v280) = v279.next(ctx) {
                                                                                                if let &InstructionData::Unary {
                                                                                                    opcode: ref v635,
                                                                                                    arg: v636,
                                                                                                } = &v280.1 {
                                                                                                    if let &Opcode::Bnot = v635 {
                                                                                                        if v2.0 == v280.0 {
                                                                                                            if v104.1 == v636 {
                                                                                                                let v875 = constructor_bxor(ctx, v2.0, v104.1, v112);
                                                                                                                // Rule at src/opts/bitops.isle line 552.
                                                                                                                returns.extend(Some(v875));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                let v879 = constructor_bxor(ctx, v2.0, v112, v104.1);
                                                                                                                // Rule at src/opts/bitops.isle line 553.
                                                                                                                returns.extend(Some(v879));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                            if v104.1 == v140.0 {
                                                                                                // Rule at src/opts/bitops.isle line 467.
                                                                                                returns.extend(Some(v104.1));
                                                                                                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 v140 = C::unpack_value_array_2(ctx, v139);
                                                                                        if v119 == v140.0 {
                                                                                            let mut v263 = C::inst_data_value_etor_returns::default();
                                                                                            C::inst_data_value_etor(ctx, v140.1, &mut v263);
                                                                                            let mut v263 = v263.into_context_iter();
                                                                                            while let Some(v264) = v263.next(ctx) {
                                                                                                if let &InstructionData::Unary {
                                                                                                    opcode: ref v632,
                                                                                                    arg: v633,
                                                                                                } = &v264.1 {
                                                                                                    if let &Opcode::Bnot = v632 {
                                                                                                        if v104.0 == v633 {
                                                                                                            if v2.0 == v264.0 {
                                                                                                                let v873 = constructor_bxor(ctx, v2.0, v104.0, v119);
                                                                                                                // Rule at src/opts/bitops.isle line 550.
                                                                                                                returns.extend(Some(v873));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                let v880 = constructor_bxor(ctx, v2.0, v119, v104.0);
                                                                                                                // Rule at src/opts/bitops.isle line 551.
                                                                                                                returns.extend(Some(v880));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                            if v104.0 == v140.1 {
                                                                                                // Rule at src/opts/bitops.isle line 469.
                                                                                                returns.extend(Some(v104.0));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                        if v119 == v140.1 {
                                                                                            let mut v279 = C::inst_data_value_etor_returns::default();
                                                                                            C::inst_data_value_etor(ctx, v140.0, &mut v279);
                                                                                            let mut v279 = v279.into_context_iter();
                                                                                            while let Some(v280) = v279.next(ctx) {
                                                                                                if let &InstructionData::Unary {
                                                                                                    opcode: ref v635,
                                                                                                    arg: v636,
                                                                                                } = &v280.1 {
                                                                                                    if let &Opcode::Bnot = v635 {
                                                                                                        if v104.0 == v636 {
                                                                                                            if v2.0 == v280.0 {
                                                                                                                let v873 = constructor_bxor(ctx, v2.0, v104.0, v119);
                                                                                                                // Rule at src/opts/bitops.isle line 548.
                                                                                                                returns.extend(Some(v873));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                let v880 = constructor_bxor(ctx, v2.0, v119, v104.0);
                                                                                                                // Rule at src/opts/bitops.isle line 555.
                                                                                                                returns.extend(Some(v880));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                            if v104.0 == v140.0 {
                                                                                                // Rule at src/opts/bitops.isle line 465.
                                                                                                returns.extend(Some(v104.0));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let v140 = C::unpack_value_array_2(ctx, v139);
                                                                        if v104.0 == v140.0 {
                                                                            let mut v263 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v140.1, &mut v263);
                                                                            let mut v263 = v263.into_context_iter();
                                                                            while let Some(v264) = v263.next(ctx) {
                                                                                if let &InstructionData::Unary {
                                                                                    opcode: ref v632,
                                                                                    arg: v633,
                                                                                } = &v264.1 {
                                                                                    if let &Opcode::Bnot = v632 {
                                                                                        if v104.1 == v633 {
                                                                                            if v2.0 == v264.0 {
                                                                                                // Rule at src/opts/bitops.isle line 464.
                                                                                                returns.extend(Some(v104.0));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            let v701 = constructor_bor(ctx, v2.0, v104.1, v140.1);
                                                                            let v702 = constructor_band(ctx, v2.0, v701, v104.0);
                                                                            // Rule at src/opts/bitops.isle line 271.
                                                                            returns.extend(Some(v702));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            let v703 = constructor_bor(ctx, v2.0, v140.1, v104.1);
                                                                            let v704 = constructor_band(ctx, v2.0, v703, v104.0);
                                                                            // Rule at src/opts/bitops.isle line 272.
                                                                            returns.extend(Some(v704));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v104.1 == v140.0 {
                                                                            let mut v263 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v140.1, &mut v263);
                                                                            let mut v263 = v263.into_context_iter();
                                                                            while let Some(v264) = v263.next(ctx) {
                                                                                if let &InstructionData::Unary {
                                                                                    opcode: ref v632,
                                                                                    arg: v633,
                                                                                } = &v264.1 {
                                                                                    if let &Opcode::Bnot = v632 {
                                                                                        if v104.0 == v633 {
                                                                                            if v2.0 == v264.0 {
                                                                                                // Rule at src/opts/bitops.isle line 468.
                                                                                                returns.extend(Some(v104.1));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            let v693 = constructor_bor(ctx, v2.0, v104.0, v140.1);
                                                                            let v694 = constructor_band(ctx, v2.0, v693, v104.1);
                                                                            // Rule at src/opts/bitops.isle line 267.
                                                                            returns.extend(Some(v694));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            let v699 = constructor_bor(ctx, v2.0, v140.1, v104.0);
                                                                            let v700 = constructor_band(ctx, v2.0, v699, v104.1);
                                                                            // Rule at src/opts/bitops.isle line 270.
                                                                            returns.extend(Some(v700));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v104.0 == v140.1 {
                                                                            let mut v279 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v140.0, &mut v279);
                                                                            let mut v279 = v279.into_context_iter();
                                                                            while let Some(v280) = v279.next(ctx) {
                                                                                if let &InstructionData::Unary {
                                                                                    opcode: ref v635,
                                                                                    arg: v636,
                                                                                } = &v280.1 {
                                                                                    if let &Opcode::Bnot = v635 {
                                                                                        if v104.1 == v636 {
                                                                                            if v2.0 == v280.0 {
                                                                                                // Rule at src/opts/bitops.isle line 466.
                                                                                                returns.extend(Some(v104.0));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            let v695 = constructor_bor(ctx, v2.0, v140.0, v104.1);
                                                                            let v696 = constructor_band(ctx, v2.0, v695, v104.0);
                                                                            // Rule at src/opts/bitops.isle line 268.
                                                                            returns.extend(Some(v696));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            let v697 = constructor_bor(ctx, v2.0, v104.1, v140.0);
                                                                            let v698 = constructor_band(ctx, v2.0, v697, v104.0);
                                                                            // Rule at src/opts/bitops.isle line 269.
                                                                            returns.extend(Some(v698));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v104.1 == v140.1 {
                                                                            let mut v279 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v140.0, &mut v279);
                                                                            let mut v279 = v279.into_context_iter();
                                                                            while let Some(v280) = v279.next(ctx) {
                                                                                if let &InstructionData::Unary {
                                                                                    opcode: ref v635,
                                                                                    arg: v636,
                                                                                } = &v280.1 {
                                                                                    if let &Opcode::Bnot = v635 {
                                                                                        if v104.0 == v636 {
                                                                                            if v2.0 == v280.0 {
                                                                                                // Rule at src/opts/bitops.isle line 470.
                                                                                                returns.extend(Some(v104.1));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            let v689 = constructor_bor(ctx, v2.0, v104.0, v140.0);
                                                                            let v690 = constructor_band(ctx, v2.0, v689, v104.1);
                                                                            // Rule at src/opts/bitops.isle line 265.
                                                                            returns.extend(Some(v690));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            let v691 = constructor_bor(ctx, v2.0, v140.0, v104.0);
                                                                            let v692 = constructor_band(ctx, v2.0, v691, v104.1);
                                                                            // Rule at src/opts/bitops.isle line 266.
                                                                            returns.extend(Some(v692));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Bxor => {
                                                                    if v2.0 == v19.0 {
                                                                        let v140 = C::unpack_value_array_2(ctx, v139);
                                                                        let mut v263 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v140.1, &mut v263);
                                                                        let mut v263 = v263.into_context_iter();
                                                                        while let Some(v264) = v263.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v632,
                                                                                arg: v633,
                                                                            } = &v264.1 {
                                                                                if let &Opcode::Bnot = v632 {
                                                                                    if v2.0 == v264.0 {
                                                                                        let v104 = C::unpack_value_array_2(ctx, v103);
                                                                                        if v104.0 == v140.0 {
                                                                                            if v104.1 == v633 {
                                                                                                let v243 = constructor_bxor(ctx, v2.0, v104.0, v104.1);
                                                                                                // Rule at src/opts/bitops.isle line 559.
                                                                                                returns.extend(Some(v243));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                        if v104.0 == v633 {
                                                                                            if v104.1 == v140.0 {
                                                                                                let v244 = constructor_bxor(ctx, v2.0, v104.1, v104.0);
                                                                                                // Rule at src/opts/bitops.isle line 561.
                                                                                                returns.extend(Some(v244));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let mut v279 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v140.0, &mut v279);
                                                                        let mut v279 = v279.into_context_iter();
                                                                        while let Some(v280) = v279.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v635,
                                                                                arg: v636,
                                                                            } = &v280.1 {
                                                                                if let &Opcode::Bnot = v635 {
                                                                                    if v2.0 == v280.0 {
                                                                                        let v104 = C::unpack_value_array_2(ctx, v103);
                                                                                        if v104.0 == v140.1 {
                                                                                            if v104.1 == v636 {
                                                                                                let v243 = constructor_bxor(ctx, v2.0, v104.0, v104.1);
                                                                                                // Rule at src/opts/bitops.isle line 563.
                                                                                                returns.extend(Some(v243));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                        if v104.0 == v636 {
                                                                                            if v104.1 == v140.1 {
                                                                                                let v244 = constructor_bxor(ctx, v2.0, v104.1, v104.0);
                                                                                                // Rule at src/opts/bitops.isle line 565.
                                                                                                returns.extend(Some(v244));
                                                                                                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 v654 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v30, &mut v654);
                                                                    let mut v654 = v654.into_context_iter();
                                                                    while let Some(v655) = v654.next(ctx) {
                                                                        if let &InstructionData::Binary {
                                                                            opcode: ref v658,
                                                                            args: ref v659,
                                                                        } = &v655.1 {
                                                                            match v658 {
                                                                                &Opcode::Bor => {
                                                                                    if v2.0 == v655.0 {
                                                                                        let v140 = C::unpack_value_array_2(ctx, v139);
                                                                                        let v660 = C::unpack_value_array_2(ctx, v659);
                                                                                        if v140.0 == v660.0 {
                                                                                            if v140.1 == v660.1 {
                                                                                                let v663 = constructor_bxor(ctx, v2.0, v660.0, v660.1);
                                                                                                let v664 = constructor_bnot(ctx, v2.0, v663);
                                                                                                // Rule at src/opts/bitops.isle line 672.
                                                                                                returns.extend(Some(v664));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v665 = constructor_bxor(ctx, v2.0, v660.1, v660.0);
                                                                                                let v666 = constructor_bnot(ctx, v2.0, v665);
                                                                                                // Rule at src/opts/bitops.isle line 678.
                                                                                                returns.extend(Some(v666));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                            let mut v263 = C::inst_data_value_etor_returns::default();
                                                                                            C::inst_data_value_etor(ctx, v140.1, &mut v263);
                                                                                            let mut v263 = v263.into_context_iter();
                                                                                            while let Some(v264) = v263.next(ctx) {
                                                                                                if let &InstructionData::Unary {
                                                                                                    opcode: ref v632,
                                                                                                    arg: v633,
                                                                                                } = &v264.1 {
                                                                                                    if let &Opcode::Bnot = v632 {
                                                                                                        if v633 == v660.1 {
                                                                                                            if v2.0 == v264.0 {
                                                                                                                let v743 = constructor_bnot(ctx, v2.0, v660.1);
                                                                                                                // Rule at src/opts/bitops.isle line 658.
                                                                                                                returns.extend(Some(v743));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                        if v140.0 == v660.1 {
                                                                                            if v140.1 == v660.0 {
                                                                                                let v665 = constructor_bxor(ctx, v2.0, v660.1, v660.0);
                                                                                                let v666 = constructor_bnot(ctx, v2.0, v665);
                                                                                                // Rule at src/opts/bitops.isle line 674.
                                                                                                returns.extend(Some(v666));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v663 = constructor_bxor(ctx, v2.0, v660.0, v660.1);
                                                                                                let v664 = constructor_bnot(ctx, v2.0, v663);
                                                                                                // Rule at src/opts/bitops.isle line 676.
                                                                                                returns.extend(Some(v664));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                            let mut v263 = C::inst_data_value_etor_returns::default();
                                                                                            C::inst_data_value_etor(ctx, v140.1, &mut v263);
                                                                                            let mut v263 = v263.into_context_iter();
                                                                                            while let Some(v264) = v263.next(ctx) {
                                                                                                if let &InstructionData::Unary {
                                                                                                    opcode: ref v632,
                                                                                                    arg: v633,
                                                                                                } = &v264.1 {
                                                                                                    if let &Opcode::Bnot = v632 {
                                                                                                        if v633 == v660.0 {
                                                                                                            if v2.0 == v264.0 {
                                                                                                                let v739 = constructor_bnot(ctx, v2.0, v660.0);
                                                                                                                // Rule at src/opts/bitops.isle line 656.
                                                                                                                returns.extend(Some(v739));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                        let mut v279 = C::inst_data_value_etor_returns::default();
                                                                                        C::inst_data_value_etor(ctx, v140.0, &mut v279);
                                                                                        let mut v279 = v279.into_context_iter();
                                                                                        while let Some(v280) = v279.next(ctx) {
                                                                                            if let &InstructionData::Unary {
                                                                                                opcode: ref v635,
                                                                                                arg: v636,
                                                                                            } = &v280.1 {
                                                                                                if let &Opcode::Bnot = v635 {
                                                                                                    if v2.0 == v280.0 {
                                                                                                        if v636 == v660.0 {
                                                                                                            if v140.1 == v660.1 {
                                                                                                                let v739 = constructor_bnot(ctx, v2.0, v660.0);
                                                                                                                // Rule at src/opts/bitops.isle line 652.
                                                                                                                returns.extend(Some(v739));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                        if v636 == v660.1 {
                                                                                                            if v140.1 == v660.0 {
                                                                                                                let v743 = constructor_bnot(ctx, v2.0, v660.1);
                                                                                                                // Rule at src/opts/bitops.isle line 654.
                                                                                                                returns.extend(Some(v743));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                                &Opcode::Bxor => {
                                                                                    if v2.0 == v655.0 {
                                                                                        let v140 = C::unpack_value_array_2(ctx, v139);
                                                                                        let v660 = C::unpack_value_array_2(ctx, v659);
                                                                                        if v140.0 == v660.0 {
                                                                                            if v140.1 == v660.1 {
                                                                                                let v663 = constructor_bxor(ctx, v2.0, v660.0, v660.1);
                                                                                                let v664 = constructor_bnot(ctx, v2.0, v663);
                                                                                                // Rule at src/opts/bitops.isle line 230.
                                                                                                returns.extend(Some(v664));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v665 = constructor_bxor(ctx, v2.0, v660.1, v660.0);
                                                                                                let v666 = constructor_bnot(ctx, v2.0, v665);
                                                                                                // Rule at src/opts/bitops.isle line 236.
                                                                                                returns.extend(Some(v666));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                        if v140.0 == v660.1 {
                                                                                            if v140.1 == v660.0 {
                                                                                                let v665 = constructor_bxor(ctx, v2.0, v660.1, v660.0);
                                                                                                let v666 = constructor_bnot(ctx, v2.0, v665);
                                                                                                // Rule at src/opts/bitops.isle line 232.
                                                                                                returns.extend(Some(v666));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v663 = constructor_bxor(ctx, v2.0, v660.0, v660.1);
                                                                                                let v664 = constructor_bnot(ctx, v2.0, v663);
                                                                                                // Rule at src/opts/bitops.isle line 234.
                                                                                                returns.extend(Some(v664));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                                _ => {}
                                                                            }
                                                                        }
                                                                    }
                                                                    let v140 = C::unpack_value_array_2(ctx, v139);
                                                                    if v30 == v140.0 {
                                                                        let v640 = constructor_bnot(ctx, v2.0, v30);
                                                                        let v641 = constructor_bor(ctx, v2.0, v140.1, v640);
                                                                        // Rule at src/opts/bitops.isle line 221.
                                                                        returns.extend(Some(v641));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v30 == v140.1 {
                                                                        let v355 = constructor_bor(ctx, v2.0, v140.0, v7.0);
                                                                        // Rule at src/opts/bitops.isle line 53.
                                                                        returns.extend(Some(v355));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let v140 = C::unpack_value_array_2(ctx, v139);
                                                let mut v263 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v140.1, &mut v263);
                                                let mut v263 = v263.into_context_iter();
                                                while let Some(v264) = v263.next(ctx) {
                                                    match &v264.1 {
                                                        &InstructionData::Binary {
                                                            opcode: ref v267,
                                                            args: ref v268,
                                                        } => {
                                                            match v267 {
                                                                &Opcode::Bor => {
                                                                    if v2.0 == v264.0 {
                                                                        let v269 = C::unpack_value_array_2(ctx, v268);
                                                                        if v7.0 == v269.0 {
                                                                            let v837 = constructor_band(ctx, v2.0, v140.0, v269.1);
                                                                            let v838 = constructor_bor(ctx, v2.0, v837, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 497.
                                                                            returns.extend(Some(v838));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.0 == v269.1 {
                                                                            let v845 = constructor_band(ctx, v2.0, v140.0, v269.0);
                                                                            let v846 = constructor_bor(ctx, v2.0, v845, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 501.
                                                                            returns.extend(Some(v846));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Bxor => {
                                                                    if v2.0 == v264.0 {
                                                                        let v269 = C::unpack_value_array_2(ctx, v268);
                                                                        if v7.0 == v269.0 {
                                                                            let v815 = constructor_band(ctx, v2.0, v269.1, v140.0);
                                                                            let v816 = constructor_bor(ctx, v2.0, v815, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 441.
                                                                            returns.extend(Some(v816));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.0 == v269.1 {
                                                                            let v807 = constructor_band(ctx, v2.0, v269.0, v140.0);
                                                                            let v808 = constructor_bor(ctx, v2.0, v807, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 437.
                                                                            returns.extend(Some(v808));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v632,
                                                            arg: v633,
                                                        } => {
                                                            if let &Opcode::Bnot = v632 {
                                                                if v7.0 == v633 {
                                                                    if v2.0 == v264.0 {
                                                                        let v790 = constructor_bor(ctx, v2.0, v7.0, v140.0);
                                                                        // Rule at src/opts/bitops.isle line 534.
                                                                        returns.extend(Some(v790));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let mut v279 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v140.0, &mut v279);
                                                let mut v279 = v279.into_context_iter();
                                                while let Some(v280) = v279.next(ctx) {
                                                    match &v280.1 {
                                                        &InstructionData::Binary {
                                                            opcode: ref v283,
                                                            args: ref v284,
                                                        } => {
                                                            match v283 {
                                                                &Opcode::Bor => {
                                                                    if v2.0 == v280.0 {
                                                                        let v285 = C::unpack_value_array_2(ctx, v284);
                                                                        if v7.0 == v285.0 {
                                                                            let v841 = constructor_band(ctx, v2.0, v140.1, v285.1);
                                                                            let v842 = constructor_bor(ctx, v2.0, v841, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 499.
                                                                            returns.extend(Some(v842));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.0 == v285.1 {
                                                                            let v849 = constructor_band(ctx, v2.0, v140.1, v285.0);
                                                                            let v850 = constructor_bor(ctx, v2.0, v849, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 503.
                                                                            returns.extend(Some(v850));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Bxor => {
                                                                    if v2.0 == v280.0 {
                                                                        let v285 = C::unpack_value_array_2(ctx, v284);
                                                                        if v7.0 == v285.0 {
                                                                            let v811 = constructor_band(ctx, v2.0, v285.1, v140.1);
                                                                            let v812 = constructor_bor(ctx, v2.0, v811, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 439.
                                                                            returns.extend(Some(v812));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.0 == v285.1 {
                                                                            let v803 = constructor_band(ctx, v2.0, v285.0, v140.1);
                                                                            let v804 = constructor_bor(ctx, v2.0, v803, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 435.
                                                                            returns.extend(Some(v804));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v635,
                                                            arg: v636,
                                                        } => {
                                                            if let &Opcode::Bnot = v635 {
                                                                if v7.0 == v636 {
                                                                    if v2.0 == v280.0 {
                                                                        let v627 = constructor_bor(ctx, v2.0, v7.0, v140.1);
                                                                        // Rule at src/opts/bitops.isle line 532.
                                                                        returns.extend(Some(v627));
                                                                        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 v1095 = C::ty_vec128(ctx, v2.0);
                                            if let Some(v1096) = v1095 {
                                                if v11.0 == v1096 {
                                                    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 v1654 = constructor_bitselect(ctx, v1096, v112, v140.1, v104.1);
                                                                                        // Rule at src/opts/selects.isle line 73.
                                                                                        returns.extend(Some(v1654));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v112 == v140.1 {
                                                                                        let v1655 = constructor_bitselect(ctx, v1096, v112, v140.0, v104.1);
                                                                                        // Rule at src/opts/selects.isle line 74.
                                                                                        returns.extend(Some(v1655));
                                                                                        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 v1656 = constructor_bitselect(ctx, v1096, v119, v140.1, v104.0);
                                                                                        // Rule at src/opts/selects.isle line 75.
                                                                                        returns.extend(Some(v1656));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v119 == v140.1 {
                                                                                        let v1657 = constructor_bitselect(ctx, v1096, v119, v140.0, v104.0);
                                                                                        // Rule at src/opts/selects.isle line 76.
                                                                                        returns.extend(Some(v1657));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    let v140 = C::unpack_value_array_2(ctx, v139);
                                                                    let mut v263 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v140.1, &mut v263);
                                                                    let mut v263 = v263.into_context_iter();
                                                                    while let Some(v264) = v263.next(ctx) {
                                                                        if let &InstructionData::Unary {
                                                                            opcode: ref v632,
                                                                            arg: v633,
                                                                        } = &v264.1 {
                                                                            if let &Opcode::Bnot = v632 {
                                                                                if v11.0 == v264.0 {
                                                                                    if v104.0 == v633 {
                                                                                        let v1651 = constructor_bitselect(ctx, v1096, v104.0, v104.1, v140.0);
                                                                                        // Rule at src/opts/selects.isle line 70.
                                                                                        returns.extend(Some(v1651));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v104.1 == v633 {
                                                                                        let v1653 = constructor_bitselect(ctx, v1096, v104.1, v104.0, v140.0);
                                                                                        // Rule at src/opts/selects.isle line 72.
                                                                                        returns.extend(Some(v1653));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    let mut v279 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v140.0, &mut v279);
                                                                    let mut v279 = v279.into_context_iter();
                                                                    while let Some(v280) = v279.next(ctx) {
                                                                        if let &InstructionData::Unary {
                                                                            opcode: ref v635,
                                                                            arg: v636,
                                                                        } = &v280.1 {
                                                                            if let &Opcode::Bnot = v635 {
                                                                                if v11.0 == v280.0 {
                                                                                    if v104.0 == v636 {
                                                                                        let v1650 = constructor_bitselect(ctx, v1096, v104.0, v104.1, v140.1);
                                                                                        // Rule at src/opts/selects.isle line 69.
                                                                                        returns.extend(Some(v1650));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v104.1 == v636 {
                                                                                        let v1652 = constructor_bitselect(ctx, v1096, v104.1, v104.0, v140.1);
                                                                                        // Rule at src/opts/selects.isle line 71.
                                                                                        returns.extend(Some(v1652));
                                                                                        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 v263 = C::inst_data_value_etor_returns::default();
                                                                                C::inst_data_value_etor(ctx, v140.1, &mut v263);
                                                                                let mut v263 = v263.into_context_iter();
                                                                                while let Some(v264) = v263.next(ctx) {
                                                                                    if let &InstructionData::UnaryImm {
                                                                                        opcode: ref v1129,
                                                                                        imm: v1130,
                                                                                    } = &v264.1 {
                                                                                        if let &Opcode::Iconst = v1129 {
                                                                                            let v689 = constructor_bor(ctx, v2.0, v104.0, v140.0);
                                                                                            let v1138 = constructor_bor(ctx, v2.0, v104.1, v140.1);
                                                                                            let v1139 = constructor_bor(ctx, v2.0, v689, v1138);
                                                                                            // Rule at src/opts/cprop.isle line 325.
                                                                                            returns.extend(Some(v1139));
                                                                                            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 615.
                                                                            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 621.
                                                                            returns.extend(Some(v246));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        let v699 = constructor_bor(ctx, v2.0, v140.1, v104.0);
                                                                        let v795 = constructor_bor(ctx, v2.0, v699, v104.1);
                                                                        // Rule at src/opts/bitops.isle line 416.
                                                                        returns.extend(Some(v795));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        let v693 = constructor_bor(ctx, v2.0, v104.0, v140.1);
                                                                        let v817 = constructor_bor(ctx, v2.0, v693, v104.1);
                                                                        // Rule at src/opts/bitops.isle line 445.
                                                                        returns.extend(Some(v817));
                                                                        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 617.
                                                                            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 619.
                                                                            returns.extend(Some(v245));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        let v691 = constructor_bor(ctx, v2.0, v140.0, v104.0);
                                                                        let v793 = constructor_bor(ctx, v2.0, v691, v104.1);
                                                                        // Rule at src/opts/bitops.isle line 414.
                                                                        returns.extend(Some(v793));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        let v689 = constructor_bor(ctx, v2.0, v104.0, v140.0);
                                                                        let v819 = constructor_bor(ctx, v2.0, v689, v104.1);
                                                                        // Rule at src/opts/bitops.isle line 449.
                                                                        returns.extend(Some(v819));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v104.1 == v140.0 {
                                                                        let v703 = constructor_bor(ctx, v2.0, v140.1, v104.1);
                                                                        let v799 = constructor_bor(ctx, v2.0, v703, v104.0);
                                                                        // Rule at src/opts/bitops.isle line 420.
                                                                        returns.extend(Some(v799));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        let v701 = constructor_bor(ctx, v2.0, v104.1, v140.1);
                                                                        let v818 = constructor_bor(ctx, v2.0, v701, v104.0);
                                                                        // Rule at src/opts/bitops.isle line 447.
                                                                        returns.extend(Some(v818));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v104.1 == v140.1 {
                                                                        let v695 = constructor_bor(ctx, v2.0, v140.0, v104.1);
                                                                        let v797 = constructor_bor(ctx, v2.0, v695, v104.0);
                                                                        // Rule at src/opts/bitops.isle line 418.
                                                                        returns.extend(Some(v797));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        let v697 = constructor_bor(ctx, v2.0, v104.1, v140.0);
                                                                        let v820 = constructor_bor(ctx, v2.0, v697, v104.0);
                                                                        // Rule at src/opts/bitops.isle line 451.
                                                                        returns.extend(Some(v820));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                    }
                                                }
                                                let v140 = C::unpack_value_array_2(ctx, v139);
                                                if v7.0 == v140.0 {
                                                    let v627 = constructor_bor(ctx, v2.0, v7.0, v140.1);
                                                    // Rule at src/opts/bitops.isle line 189.
                                                    returns.extend(Some(v627));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.0 == v140.1 {
                                                    let v355 = constructor_bor(ctx, v2.0, v140.0, v7.0);
                                                    // Rule at src/opts/bitops.isle line 190.
                                                    returns.extend(Some(v355));
                                                    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 v289,
                                                                                    args: ref v290,
                                                                                } = &v108.1 {
                                                                                    if let &Opcode::Ishl = v289 {
                                                                                        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 v273,
                                                                                                    args: ref v274,
                                                                                                } = &v115.1 {
                                                                                                    if let &Opcode::Ishl = v273 {
                                                                                                        let v140 = C::unpack_value_array_2(ctx, v139);
                                                                                                        let mut v263 = C::inst_data_value_etor_returns::default();
                                                                                                        C::inst_data_value_etor(ctx, v140.1, &mut v263);
                                                                                                        let mut v263 = v263.into_context_iter();
                                                                                                        while let Some(v264) = v263.next(ctx) {
                                                                                                            if v264.0 == I32 {
                                                                                                                if let &InstructionData::Binary {
                                                                                                                    opcode: ref v267,
                                                                                                                    args: ref v268,
                                                                                                                } = &v264.1 {
                                                                                                                    if let &Opcode::Ushr = v267 {
                                                                                                                        let v269 = C::unpack_value_array_2(ctx, v268);
                                                                                                                        let v291 = C::unpack_value_array_2(ctx, v290);
                                                                                                                        if v269.0 == v291.0 {
                                                                                                                            let mut v279 = C::inst_data_value_etor_returns::default();
                                                                                                                            C::inst_data_value_etor(ctx, v140.0, &mut v279);
                                                                                                                            let mut v279 = v279.into_context_iter();
                                                                                                                            while let Some(v280) = v279.next(ctx) {
                                                                                                                                if v280.0 == I32 {
                                                                                                                                    if let &InstructionData::Binary {
                                                                                                                                        opcode: ref v283,
                                                                                                                                        args: ref v284,
                                                                                                                                    } = &v280.1 {
                                                                                                                                        if let &Opcode::Band = v283 {
                                                                                                                                            let mut v389 = C::inst_data_value_etor_returns::default();
                                                                                                                                            C::inst_data_value_etor(ctx, v291.1, &mut v389);
                                                                                                                                            let mut v389 = v389.into_context_iter();
                                                                                                                                            while let Some(v390) = v389.next(ctx) {
                                                                                                                                                if v390.0 == I32 {
                                                                                                                                                    if let &InstructionData::UnaryImm {
                                                                                                                                                        opcode: ref v393,
                                                                                                                                                        imm: v394,
                                                                                                                                                    } = &v390.1 {
                                                                                                                                                        if let &Opcode::Iconst = v393 {
                                                                                                                                                            let v395 = C::u64_from_imm64(ctx, v394);
                                                                                                                                                            if v395 == 0x18_u64 {
                                                                                                                                                                let v275 = C::unpack_value_array_2(ctx, v274);
                                                                                                                                                                let mut v396 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                C::inst_data_value_etor(ctx, v275.0, &mut v396);
                                                                                                                                                                let mut v396 = v396.into_context_iter();
                                                                                                                                                                while let Some(v397) = v396.next(ctx) {
                                                                                                                                                                    if v397.0 == I32 {
                                                                                                                                                                        if let &InstructionData::Binary {
                                                                                                                                                                            opcode: ref v400,
                                                                                                                                                                            args: ref v401,
                                                                                                                                                                        } = &v397.1 {
                                                                                                                                                                            if let &Opcode::Band = v400 {
                                                                                                                                                                                let v402 = C::unpack_value_array_2(ctx, v401);
                                                                                                                                                                                if v269.0 == v402.0 {
                                                                                                                                                                                    let mut v405 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                    C::inst_data_value_etor(ctx, v402.1, &mut v405);
                                                                                                                                                                                    let mut v405 = v405.into_context_iter();
                                                                                                                                                                                    while let Some(v406) = v405.next(ctx) {
                                                                                                                                                                                        if v406.0 == I32 {
                                                                                                                                                                                            if let &InstructionData::UnaryImm {
                                                                                                                                                                                                opcode: ref v409,
                                                                                                                                                                                                imm: v410,
                                                                                                                                                                                            } = &v406.1 {
                                                                                                                                                                                                if let &Opcode::Iconst = v409 {
                                                                                                                                                                                                    let v411 = C::u64_from_imm64(ctx, v410);
                                                                                                                                                                                                    if v411 == 0xff00_u64 {
                                                                                                                                                                                                        let mut v412 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                        C::inst_data_value_etor(ctx, v275.1, &mut v412);
                                                                                                                                                                                                        let mut v412 = v412.into_context_iter();
                                                                                                                                                                                                        while let Some(v413) = v412.next(ctx) {
                                                                                                                                                                                                            if v413.0 == I32 {
                                                                                                                                                                                                                if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                    opcode: ref v416,
                                                                                                                                                                                                                    imm: v417,
                                                                                                                                                                                                                } = &v413.1 {
                                                                                                                                                                                                                    if let &Opcode::Iconst = v416 {
                                                                                                                                                                                                                        let v418 = C::u64_from_imm64(ctx, v417);
                                                                                                                                                                                                                        if v418 == 0x8_u64 {
                                                                                                                                                                                                                            let v285 = C::unpack_value_array_2(ctx, v284);
                                                                                                                                                                                                                            let mut v419 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                            C::inst_data_value_etor(ctx, v285.0, &mut v419);
                                                                                                                                                                                                                            let mut v419 = v419.into_context_iter();
                                                                                                                                                                                                                            while let Some(v420) = v419.next(ctx) {
                                                                                                                                                                                                                                if v420.0 == I32 {
                                                                                                                                                                                                                                    if let &InstructionData::Binary {
                                                                                                                                                                                                                                        opcode: ref v423,
                                                                                                                                                                                                                                        args: ref v424,
                                                                                                                                                                                                                                    } = &v420.1 {
                                                                                                                                                                                                                                        if let &Opcode::Ushr = v423 {
                                                                                                                                                                                                                                            let v425 = C::unpack_value_array_2(ctx, v424);
                                                                                                                                                                                                                                            if v269.0 == v425.0 {
                                                                                                                                                                                                                                                let mut v428 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                C::inst_data_value_etor(ctx, v425.1, &mut v428);
                                                                                                                                                                                                                                                let mut v428 = v428.into_context_iter();
                                                                                                                                                                                                                                                while let Some(v429) = v428.next(ctx) {
                                                                                                                                                                                                                                                    if v429.0 == I32 {
                                                                                                                                                                                                                                                        if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                            opcode: ref v432,
                                                                                                                                                                                                                                                            imm: v433,
                                                                                                                                                                                                                                                        } = &v429.1 {
                                                                                                                                                                                                                                                            if let &Opcode::Iconst = v432 {
                                                                                                                                                                                                                                                                let v434 = C::u64_from_imm64(ctx, v433);
                                                                                                                                                                                                                                                                if v434 == 0x8_u64 {
                                                                                                                                                                                                                                                                    let mut v435 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                    C::inst_data_value_etor(ctx, v285.1, &mut v435);
                                                                                                                                                                                                                                                                    let mut v435 = v435.into_context_iter();
                                                                                                                                                                                                                                                                    while let Some(v436) = v435.next(ctx) {
                                                                                                                                                                                                                                                                        if v436.0 == I32 {
                                                                                                                                                                                                                                                                            if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                opcode: ref v439,
                                                                                                                                                                                                                                                                                imm: v440,
                                                                                                                                                                                                                                                                            } = &v436.1 {
                                                                                                                                                                                                                                                                                if let &Opcode::Iconst = v439 {
                                                                                                                                                                                                                                                                                    let v441 = C::u64_from_imm64(ctx, v440);
                                                                                                                                                                                                                                                                                    if v441 == 0xff00_u64 {
                                                                                                                                                                                                                                                                                        let mut v442 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                        C::inst_data_value_etor(ctx, v269.1, &mut v442);
                                                                                                                                                                                                                                                                                        let mut v442 = v442.into_context_iter();
                                                                                                                                                                                                                                                                                        while let Some(v443) = v442.next(ctx) {
                                                                                                                                                                                                                                                                                            if v443.0 == I32 {
                                                                                                                                                                                                                                                                                                if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                    opcode: ref v446,
                                                                                                                                                                                                                                                                                                    imm: v447,
                                                                                                                                                                                                                                                                                                } = &v443.1 {
                                                                                                                                                                                                                                                                                                    if let &Opcode::Iconst = v446 {
                                                                                                                                                                                                                                                                                                        let v448 = C::u64_from_imm64(ctx, v447);
                                                                                                                                                                                                                                                                                                        if v448 == 0x18_u64 {
                                                                                                                                                                                                                                                                                                            let v449 = constructor_bswap(ctx, v2.0, v291.0);
                                                                                                                                                                                                                                                                                                            // Rule at src/opts/bitops.isle line 142.
                                                                                                                                                                                                                                                                                                            returns.extend(Some(v449));
                                                                                                                                                                                                                                                                                                            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 v289,
                                                                                    args: ref v290,
                                                                                } = &v108.1 {
                                                                                    if let &Opcode::Bor = v289 {
                                                                                        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 v273,
                                                                                                    args: ref v274,
                                                                                                } = &v115.1 {
                                                                                                    if let &Opcode::Bor = v273 {
                                                                                                        let v140 = C::unpack_value_array_2(ctx, v139);
                                                                                                        let mut v263 = C::inst_data_value_etor_returns::default();
                                                                                                        C::inst_data_value_etor(ctx, v140.1, &mut v263);
                                                                                                        let mut v263 = v263.into_context_iter();
                                                                                                        while let Some(v264) = v263.next(ctx) {
                                                                                                            if v264.0 == I64 {
                                                                                                                if let &InstructionData::Binary {
                                                                                                                    opcode: ref v267,
                                                                                                                    args: ref v268,
                                                                                                                } = &v264.1 {
                                                                                                                    if let &Opcode::Bor = v267 {
                                                                                                                        let mut v279 = C::inst_data_value_etor_returns::default();
                                                                                                                        C::inst_data_value_etor(ctx, v140.0, &mut v279);
                                                                                                                        let mut v279 = v279.into_context_iter();
                                                                                                                        while let Some(v280) = v279.next(ctx) {
                                                                                                                            if v280.0 == I64 {
                                                                                                                                if let &InstructionData::Binary {
                                                                                                                                    opcode: ref v283,
                                                                                                                                    args: ref v284,
                                                                                                                                } = &v280.1 {
                                                                                                                                    if let &Opcode::Bor = v283 {
                                                                                                                                        let v291 = C::unpack_value_array_2(ctx, v290);
                                                                                                                                        let mut v389 = C::inst_data_value_etor_returns::default();
                                                                                                                                        C::inst_data_value_etor(ctx, v291.1, &mut v389);
                                                                                                                                        let mut v389 = v389.into_context_iter();
                                                                                                                                        while let Some(v390) = v389.next(ctx) {
                                                                                                                                            if v390.0 == I64 {
                                                                                                                                                if let &InstructionData::Binary {
                                                                                                                                                    opcode: ref v466,
                                                                                                                                                    args: ref v467,
                                                                                                                                                } = &v390.1 {
                                                                                                                                                    if let &Opcode::Ishl = v466 {
                                                                                                                                                        let v275 = C::unpack_value_array_2(ctx, v274);
                                                                                                                                                        let mut v396 = C::inst_data_value_etor_returns::default();
                                                                                                                                                        C::inst_data_value_etor(ctx, v275.0, &mut v396);
                                                                                                                                                        let mut v396 = v396.into_context_iter();
                                                                                                                                                        while let Some(v397) = v396.next(ctx) {
                                                                                                                                                            if v397.0 == I64 {
                                                                                                                                                                if let &InstructionData::Binary {
                                                                                                                                                                    opcode: ref v400,
                                                                                                                                                                    args: ref v401,
                                                                                                                                                                } = &v397.1 {
                                                                                                                                                                    if let &Opcode::Ishl = v400 {
                                                                                                                                                                        let v402 = C::unpack_value_array_2(ctx, v401);
                                                                                                                                                                        let mut v405 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                        C::inst_data_value_etor(ctx, v402.1, &mut v405);
                                                                                                                                                                        let mut v405 = v405.into_context_iter();
                                                                                                                                                                        while let Some(v406) = v405.next(ctx) {
                                                                                                                                                                            if v406.0 == I64 {
                                                                                                                                                                                if let &InstructionData::UnaryImm {
                                                                                                                                                                                    opcode: ref v409,
                                                                                                                                                                                    imm: v410,
                                                                                                                                                                                } = &v406.1 {
                                                                                                                                                                                    if let &Opcode::Iconst = v409 {
                                                                                                                                                                                        let v411 = C::u64_from_imm64(ctx, v410);
                                                                                                                                                                                        if v411 == 0x18_u64 {
                                                                                                                                                                                            let mut v412 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                            C::inst_data_value_etor(ctx, v275.1, &mut v412);
                                                                                                                                                                                            let mut v412 = v412.into_context_iter();
                                                                                                                                                                                            while let Some(v413) = v412.next(ctx) {
                                                                                                                                                                                                if v413.0 == I64 {
                                                                                                                                                                                                    if let &InstructionData::Binary {
                                                                                                                                                                                                        opcode: ref v510,
                                                                                                                                                                                                        args: ref v511,
                                                                                                                                                                                                    } = &v413.1 {
                                                                                                                                                                                                        if let &Opcode::Ishl = v510 {
                                                                                                                                                                                                            let v285 = C::unpack_value_array_2(ctx, v284);
                                                                                                                                                                                                            let mut v419 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                            C::inst_data_value_etor(ctx, v285.0, &mut v419);
                                                                                                                                                                                                            let mut v419 = v419.into_context_iter();
                                                                                                                                                                                                            while let Some(v420) = v419.next(ctx) {
                                                                                                                                                                                                                if v420.0 == I64 {
                                                                                                                                                                                                                    if let &InstructionData::Binary {
                                                                                                                                                                                                                        opcode: ref v423,
                                                                                                                                                                                                                        args: ref v424,
                                                                                                                                                                                                                    } = &v420.1 {
                                                                                                                                                                                                                        if let &Opcode::Band = v423 {
                                                                                                                                                                                                                            let v425 = C::unpack_value_array_2(ctx, v424);
                                                                                                                                                                                                                            let mut v428 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                            C::inst_data_value_etor(ctx, v425.1, &mut v428);
                                                                                                                                                                                                                            let mut v428 = v428.into_context_iter();
                                                                                                                                                                                                                            while let Some(v429) = v428.next(ctx) {
                                                                                                                                                                                                                                if v429.0 == I64 {
                                                                                                                                                                                                                                    if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                        opcode: ref v432,
                                                                                                                                                                                                                                        imm: v433,
                                                                                                                                                                                                                                    } = &v429.1 {
                                                                                                                                                                                                                                        if let &Opcode::Iconst = v432 {
                                                                                                                                                                                                                                            let v434 = C::u64_from_imm64(ctx, v433);
                                                                                                                                                                                                                                            if v434 == 0xff000000_u64 {
                                                                                                                                                                                                                                                let mut v435 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                C::inst_data_value_etor(ctx, v285.1, &mut v435);
                                                                                                                                                                                                                                                let mut v435 = v435.into_context_iter();
                                                                                                                                                                                                                                                while let Some(v436) = v435.next(ctx) {
                                                                                                                                                                                                                                                    if v436.0 == I64 {
                                                                                                                                                                                                                                                        if let &InstructionData::Binary {
                                                                                                                                                                                                                                                            opcode: ref v554,
                                                                                                                                                                                                                                                            args: ref v555,
                                                                                                                                                                                                                                                        } = &v436.1 {
                                                                                                                                                                                                                                                            if let &Opcode::Band = v554 {
                                                                                                                                                                                                                                                                let v269 = C::unpack_value_array_2(ctx, v268);
                                                                                                                                                                                                                                                                let mut v442 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                C::inst_data_value_etor(ctx, v269.1, &mut v442);
                                                                                                                                                                                                                                                                let mut v442 = v442.into_context_iter();
                                                                                                                                                                                                                                                                while let Some(v443) = v442.next(ctx) {
                                                                                                                                                                                                                                                                    if v443.0 == I64 {
                                                                                                                                                                                                                                                                        if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                            opcode: ref v614,
                                                                                                                                                                                                                                                                            args: ref v615,
                                                                                                                                                                                                                                                                        } = &v443.1 {
                                                                                                                                                                                                                                                                            if let &Opcode::Ushr = v614 {
                                                                                                                                                                                                                                                                                let mut v450 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                C::inst_data_value_etor(ctx, v291.0, &mut v450);
                                                                                                                                                                                                                                                                                let mut v450 = v450.into_context_iter();
                                                                                                                                                                                                                                                                                while let Some(v451) = v450.next(ctx) {
                                                                                                                                                                                                                                                                                    if v451.0 == I64 {
                                                                                                                                                                                                                                                                                        if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                                            opcode: ref v454,
                                                                                                                                                                                                                                                                                            args: ref v455,
                                                                                                                                                                                                                                                                                        } = &v451.1 {
                                                                                                                                                                                                                                                                                            if let &Opcode::Ishl = v454 {
                                                                                                                                                                                                                                                                                                let v456 = C::unpack_value_array_2(ctx, v455);
                                                                                                                                                                                                                                                                                                let v616 = C::unpack_value_array_2(ctx, v615);
                                                                                                                                                                                                                                                                                                if v456.0 == v616.0 {
                                                                                                                                                                                                                                                                                                    let mut v459 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                    C::inst_data_value_etor(ctx, v456.1, &mut v459);
                                                                                                                                                                                                                                                                                                    let mut v459 = v459.into_context_iter();
                                                                                                                                                                                                                                                                                                    while let Some(v460) = v459.next(ctx) {
                                                                                                                                                                                                                                                                                                        if v460.0 == I64 {
                                                                                                                                                                                                                                                                                                            if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                opcode: ref v463,
                                                                                                                                                                                                                                                                                                                imm: v464,
                                                                                                                                                                                                                                                                                                            } = &v460.1 {
                                                                                                                                                                                                                                                                                                                if let &Opcode::Iconst = v463 {
                                                                                                                                                                                                                                                                                                                    let v465 = C::u64_from_imm64(ctx, v464);
                                                                                                                                                                                                                                                                                                                    if v465 == 0x38_u64 {
                                                                                                                                                                                                                                                                                                                        let v468 = C::unpack_value_array_2(ctx, v467);
                                                                                                                                                                                                                                                                                                                        let mut v471 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                        C::inst_data_value_etor(ctx, v468.0, &mut v471);
                                                                                                                                                                                                                                                                                                                        let mut v471 = v471.into_context_iter();
                                                                                                                                                                                                                                                                                                                        while let Some(v472) = v471.next(ctx) {
                                                                                                                                                                                                                                                                                                                            if v472.0 == I64 {
                                                                                                                                                                                                                                                                                                                                if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                                                                                    opcode: ref v475,
                                                                                                                                                                                                                                                                                                                                    args: ref v476,
                                                                                                                                                                                                                                                                                                                                } = &v472.1 {
                                                                                                                                                                                                                                                                                                                                    if let &Opcode::Band = v475 {
                                                                                                                                                                                                                                                                                                                                        let v477 = C::unpack_value_array_2(ctx, v476);
                                                                                                                                                                                                                                                                                                                                        if v456.0 == v477.0 {
                                                                                                                                                                                                                                                                                                                                            let mut v480 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                            C::inst_data_value_etor(ctx, v477.1, &mut v480);
                                                                                                                                                                                                                                                                                                                                            let mut v480 = v480.into_context_iter();
                                                                                                                                                                                                                                                                                                                                            while let Some(v481) = v480.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                if v481.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                    if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                        opcode: ref v484,
                                                                                                                                                                                                                                                                                                                                                        imm: v485,
                                                                                                                                                                                                                                                                                                                                                    } = &v481.1 {
                                                                                                                                                                                                                                                                                                                                                        if let &Opcode::Iconst = v484 {
                                                                                                                                                                                                                                                                                                                                                            let v486 = C::u64_from_imm64(ctx, v485);
                                                                                                                                                                                                                                                                                                                                                            if v486 == 0xff00_u64 {
                                                                                                                                                                                                                                                                                                                                                                let mut v487 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                C::inst_data_value_etor(ctx, v468.1, &mut v487);
                                                                                                                                                                                                                                                                                                                                                                let mut v487 = v487.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                while let Some(v488) = v487.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                    if v488.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                        if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                            opcode: ref v491,
                                                                                                                                                                                                                                                                                                                                                                            imm: v492,
                                                                                                                                                                                                                                                                                                                                                                        } = &v488.1 {
                                                                                                                                                                                                                                                                                                                                                                            if let &Opcode::Iconst = v491 {
                                                                                                                                                                                                                                                                                                                                                                                let v493 = C::u64_from_imm64(ctx, v492);
                                                                                                                                                                                                                                                                                                                                                                                if v493 == 0x28_u64 {
                                                                                                                                                                                                                                                                                                                                                                                    let mut v494 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                    C::inst_data_value_etor(ctx, v402.0, &mut v494);
                                                                                                                                                                                                                                                                                                                                                                                    let mut v494 = v494.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                    while let Some(v495) = v494.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                        if v495.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                            if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                                                                                                                                                opcode: ref v498,
                                                                                                                                                                                                                                                                                                                                                                                                args: ref v499,
                                                                                                                                                                                                                                                                                                                                                                                            } = &v495.1 {
                                                                                                                                                                                                                                                                                                                                                                                                if let &Opcode::Band = v498 {
                                                                                                                                                                                                                                                                                                                                                                                                    let v500 = C::unpack_value_array_2(ctx, v499);
                                                                                                                                                                                                                                                                                                                                                                                                    if v456.0 == v500.0 {
                                                                                                                                                                                                                                                                                                                                                                                                        let mut v503 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                        C::inst_data_value_etor(ctx, v500.1, &mut v503);
                                                                                                                                                                                                                                                                                                                                                                                                        let mut v503 = v503.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                        while let Some(v504) = v503.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                            if v504.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                                                                    opcode: ref v507,
                                                                                                                                                                                                                                                                                                                                                                                                                    imm: v508,
                                                                                                                                                                                                                                                                                                                                                                                                                } = &v504.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                    if let &Opcode::Iconst = v507 {
                                                                                                                                                                                                                                                                                                                                                                                                                        let v509 = C::u64_from_imm64(ctx, v508);
                                                                                                                                                                                                                                                                                                                                                                                                                        if v509 == 0xff0000_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                            let v512 = C::unpack_value_array_2(ctx, v511);
                                                                                                                                                                                                                                                                                                                                                                                                                            let mut v515 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                            C::inst_data_value_etor(ctx, v512.0, &mut v515);
                                                                                                                                                                                                                                                                                                                                                                                                                            let mut v515 = v515.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                            while let Some(v516) = v515.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                if v516.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                    if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                                                                                                                                                                                        opcode: ref v519,
                                                                                                                                                                                                                                                                                                                                                                                                                                        args: ref v520,
                                                                                                                                                                                                                                                                                                                                                                                                                                    } = &v516.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                        if let &Opcode::Band = v519 {
                                                                                                                                                                                                                                                                                                                                                                                                                                            let v521 = C::unpack_value_array_2(ctx, v520);
                                                                                                                                                                                                                                                                                                                                                                                                                                            if v456.0 == v521.0 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                let mut v524 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                C::inst_data_value_etor(ctx, v521.1, &mut v524);
                                                                                                                                                                                                                                                                                                                                                                                                                                                let mut v524 = v524.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                while let Some(v525) = v524.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                    if v525.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                        if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                                                                                                            opcode: ref v528,
                                                                                                                                                                                                                                                                                                                                                                                                                                                            imm: v529,
                                                                                                                                                                                                                                                                                                                                                                                                                                                        } = &v525.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                            if let &Opcode::Iconst = v528 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                let v530 = C::u64_from_imm64(ctx, v529);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                if v530 == 0xff000000_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mut v531 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    C::inst_data_value_etor(ctx, v512.1, &mut v531);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mut v531 = v531.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    while let Some(v532) = v531.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if v532.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                opcode: ref v535,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                imm: v536,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } = &v532.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if let &Opcode::Iconst = v535 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let v537 = C::u64_from_imm64(ctx, v536);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if v537 == 0x8_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mut v538 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        C::inst_data_value_etor(ctx, v425.0, &mut v538);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mut v538 = v538.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        while let Some(v539) = v538.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if v539.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opcode: ref v542,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    args: ref v543,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } = &v539.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if let &Opcode::Ushr = v542 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let v544 = C::unpack_value_array_2(ctx, v543);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if v456.0 == v544.0 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mut v547 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            C::inst_data_value_etor(ctx, v544.1, &mut v547);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mut v547 = v547.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            while let Some(v548) = v547.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if v548.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opcode: ref v551,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        imm: v552,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } = &v548.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if let &Opcode::Iconst = v551 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let v553 = C::u64_from_imm64(ctx, v552);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if v553 == 0x8_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let v556 = C::unpack_value_array_2(ctx, v555);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mut v559 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                C::inst_data_value_etor(ctx, v556.0, &mut v559);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mut v559 = v559.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                while let Some(v560) = v559.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if v560.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            opcode: ref v563,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            args: ref v564,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } = &v560.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if let &Opcode::Ushr = v563 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let v565 = C::unpack_value_array_2(ctx, v564);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if v456.0 == v565.0 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mut v568 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    C::inst_data_value_etor(ctx, v565.1, &mut v568);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mut v568 = v568.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    while let Some(v569) = v568.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if v569.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                opcode: ref v572,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                imm: v573,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } = &v569.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if let &Opcode::Iconst = v572 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let v574 = C::u64_from_imm64(ctx, v573);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if v574 == 0x18_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mut v575 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        C::inst_data_value_etor(ctx, v556.1, &mut v575);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mut v575 = v575.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        while let Some(v576) = v575.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if v576.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opcode: ref v579,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    imm: v580,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } = &v576.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if let &Opcode::Iconst = v579 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let v581 = C::u64_from_imm64(ctx, v580);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if v581 == 0xff0000_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mut v582 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            C::inst_data_value_etor(ctx, v269.0, &mut v582);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mut v582 = v582.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            while let Some(v583) = v582.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if v583.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opcode: ref v586,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        args: ref v587,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } = &v583.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if let &Opcode::Band = v586 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let v588 = C::unpack_value_array_2(ctx, v587);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mut v591 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            C::inst_data_value_etor(ctx, v588.0, &mut v591);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mut v591 = v591.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            while let Some(v592) = v591.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if v592.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opcode: ref v595,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        args: ref v596,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } = &v592.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if let &Opcode::Ushr = v595 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let v597 = C::unpack_value_array_2(ctx, v596);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if v456.0 == v597.0 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                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 == 0x28_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mut v607 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    C::inst_data_value_etor(ctx, v588.1, &mut v607);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mut v607 = v607.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    while let Some(v608) = v607.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if v608.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                opcode: ref v611,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                imm: v612,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } = &v608.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if let &Opcode::Iconst = v611 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let v613 = C::u64_from_imm64(ctx, v612);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if v613 == 0xff00_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mut v619 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        C::inst_data_value_etor(ctx, v616.1, &mut v619);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mut v619 = v619.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        while let Some(v620) = v619.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if v620.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opcode: ref v623,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    imm: v624,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } = &v620.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if let &Opcode::Iconst = v623 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let v625 = C::u64_from_imm64(ctx, v624);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if v625 == 0x38_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let v626 = constructor_bswap(ctx, v2.0, v456.0);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            // Rule at src/opts/bitops.isle line 155.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            returns.extend(Some(v626));
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            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::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 {
                                                                                        let v140 = C::unpack_value_array_2(ctx, v139);
                                                                                        if v104.1 == v140.0 {
                                                                                            if v112 == v140.1 {
                                                                                                let v875 = constructor_bxor(ctx, v2.0, v104.1, v112);
                                                                                                // Rule at src/opts/bitops.isle line 562.
                                                                                                returns.extend(Some(v875));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                        if v112 == v140.0 {
                                                                                            if v104.1 == v140.1 {
                                                                                                let v875 = constructor_bxor(ctx, v2.0, v104.1, v112);
                                                                                                // Rule at src/opts/bitops.isle line 564.
                                                                                                returns.extend(Some(v875));
                                                                                                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 v140 = C::unpack_value_array_2(ctx, v139);
                                                                                        if v104.0 == v140.0 {
                                                                                            if v119 == v140.1 {
                                                                                                let v873 = constructor_bxor(ctx, v2.0, v104.0, v119);
                                                                                                // Rule at src/opts/bitops.isle line 558.
                                                                                                returns.extend(Some(v873));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                        if v119 == v140.0 {
                                                                                            if v104.0 == v140.1 {
                                                                                                let v873 = constructor_bxor(ctx, v2.0, v104.0, v119);
                                                                                                // Rule at src/opts/bitops.isle line 560.
                                                                                                returns.extend(Some(v873));
                                                                                                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 v245 = constructor_bor(ctx, v2.0, v104.0, v104.1);
                                                                                // Rule at src/opts/bitops.isle line 614.
                                                                                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 620.
                                                                                returns.extend(Some(v246));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                            let v246 = constructor_bor(ctx, v2.0, v104.1, v104.0);
                                                                            let v796 = constructor_bor(ctx, v2.0, v246, v140.1);
                                                                            // Rule at src/opts/bitops.isle line 417.
                                                                            returns.extend(Some(v796));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            let v245 = constructor_bor(ctx, v2.0, v104.0, v104.1);
                                                                            let v794 = constructor_bor(ctx, v2.0, v245, v140.1);
                                                                            // Rule at src/opts/bitops.isle line 444.
                                                                            returns.extend(Some(v794));
                                                                            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 616.
                                                                                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 618.
                                                                                returns.extend(Some(v246));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                            let v246 = constructor_bor(ctx, v2.0, v104.1, v104.0);
                                                                            let v800 = constructor_bor(ctx, v2.0, v246, v140.0);
                                                                            // Rule at src/opts/bitops.isle line 421.
                                                                            returns.extend(Some(v800));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            let v245 = constructor_bor(ctx, v2.0, v104.0, v104.1);
                                                                            let v798 = constructor_bor(ctx, v2.0, v245, v140.0);
                                                                            // Rule at src/opts/bitops.isle line 446.
                                                                            returns.extend(Some(v798));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v104.1 == v140.0 {
                                                                            let v245 = constructor_bor(ctx, v2.0, v104.0, v104.1);
                                                                            let v794 = constructor_bor(ctx, v2.0, v245, v140.1);
                                                                            // Rule at src/opts/bitops.isle line 415.
                                                                            returns.extend(Some(v794));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            let v246 = constructor_bor(ctx, v2.0, v104.1, v104.0);
                                                                            let v796 = constructor_bor(ctx, v2.0, v246, v140.1);
                                                                            // Rule at src/opts/bitops.isle line 448.
                                                                            returns.extend(Some(v796));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v104.1 == v140.1 {
                                                                            let v245 = constructor_bor(ctx, v2.0, v104.0, v104.1);
                                                                            let v798 = constructor_bor(ctx, v2.0, v245, v140.0);
                                                                            // Rule at src/opts/bitops.isle line 419.
                                                                            returns.extend(Some(v798));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            let v246 = constructor_bor(ctx, v2.0, v104.1, v104.0);
                                                                            let v800 = constructor_bor(ctx, v2.0, v246, v140.0);
                                                                            // Rule at src/opts/bitops.isle line 450.
                                                                            returns.extend(Some(v800));
                                                                            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 v289,
                                                                                args: ref v290,
                                                                            } = &v108.1 {
                                                                                if let &Opcode::Bxor = v289 {
                                                                                    if v2.0 == v108.0 {
                                                                                        let v140 = C::unpack_value_array_2(ctx, v139);
                                                                                        let v291 = C::unpack_value_array_2(ctx, v290);
                                                                                        if v140.0 == v291.0 {
                                                                                            if v140.1 == v291.1 {
                                                                                                let v779 = constructor_bxor(ctx, v2.0, v291.0, v291.1);
                                                                                                let v780 = constructor_bor(ctx, v2.0, v779, v104.1);
                                                                                                // Rule at src/opts/bitops.isle line 384.
                                                                                                returns.extend(Some(v780));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v784 = constructor_bxor(ctx, v2.0, v291.1, v291.0);
                                                                                                let v785 = constructor_bor(ctx, v2.0, v784, v104.1);
                                                                                                // Rule at src/opts/bitops.isle line 399.
                                                                                                returns.extend(Some(v785));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                        if v140.0 == v291.1 {
                                                                                            if v140.1 == v291.0 {
                                                                                                let v784 = constructor_bxor(ctx, v2.0, v291.1, v291.0);
                                                                                                let v785 = constructor_bor(ctx, v2.0, v784, v104.1);
                                                                                                // Rule at src/opts/bitops.isle line 389.
                                                                                                returns.extend(Some(v785));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v779 = constructor_bxor(ctx, v2.0, v291.0, v291.1);
                                                                                                let v780 = constructor_bor(ctx, v2.0, v779, v104.1);
                                                                                                // Rule at src/opts/bitops.isle line 394.
                                                                                                returns.extend(Some(v780));
                                                                                                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 v273,
                                                                                args: ref v274,
                                                                            } = &v115.1 {
                                                                                if let &Opcode::Bxor = v273 {
                                                                                    if v2.0 == v115.0 {
                                                                                        let v140 = C::unpack_value_array_2(ctx, v139);
                                                                                        let v275 = C::unpack_value_array_2(ctx, v274);
                                                                                        if v140.0 == v275.0 {
                                                                                            if v140.1 == v275.1 {
                                                                                                let v782 = constructor_bxor(ctx, v2.0, v275.0, v275.1);
                                                                                                let v783 = constructor_bor(ctx, v2.0, v782, v104.0);
                                                                                                // Rule at src/opts/bitops.isle line 386.
                                                                                                returns.extend(Some(v783));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v786 = constructor_bxor(ctx, v2.0, v275.1, v275.0);
                                                                                                let v787 = constructor_bor(ctx, v2.0, v786, v104.0);
                                                                                                // Rule at src/opts/bitops.isle line 401.
                                                                                                returns.extend(Some(v787));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                        if v140.0 == v275.1 {
                                                                                            if v140.1 == v275.0 {
                                                                                                let v786 = constructor_bxor(ctx, v2.0, v275.1, v275.0);
                                                                                                let v787 = constructor_bor(ctx, v2.0, v786, v104.0);
                                                                                                // Rule at src/opts/bitops.isle line 391.
                                                                                                returns.extend(Some(v787));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v782 = constructor_bxor(ctx, v2.0, v275.0, v275.1);
                                                                                                let v783 = constructor_bor(ctx, v2.0, v782, v104.0);
                                                                                                // Rule at src/opts/bitops.isle line 396.
                                                                                                returns.extend(Some(v783));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let v140 = C::unpack_value_array_2(ctx, v139);
                                                                        let mut v263 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v140.1, &mut v263);
                                                                        let mut v263 = v263.into_context_iter();
                                                                        while let Some(v264) = v263.next(ctx) {
                                                                            if let &InstructionData::Binary {
                                                                                opcode: ref v267,
                                                                                args: ref v268,
                                                                            } = &v264.1 {
                                                                                if let &Opcode::Bxor = v267 {
                                                                                    if v2.0 == v264.0 {
                                                                                        let v269 = C::unpack_value_array_2(ctx, v268);
                                                                                        if v104.0 == v269.0 {
                                                                                            if v104.1 == v269.1 {
                                                                                                let v243 = constructor_bxor(ctx, v2.0, v104.0, v104.1);
                                                                                                let v781 = constructor_bor(ctx, v2.0, v243, v140.0);
                                                                                                // Rule at src/opts/bitops.isle line 385.
                                                                                                returns.extend(Some(v781));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v244 = constructor_bxor(ctx, v2.0, v104.1, v104.0);
                                                                                                let v789 = constructor_bor(ctx, v2.0, v244, v140.0);
                                                                                                // Rule at src/opts/bitops.isle line 400.
                                                                                                returns.extend(Some(v789));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                        if v104.1 == v269.0 {
                                                                                            if v104.0 == v269.1 {
                                                                                                let v243 = constructor_bxor(ctx, v2.0, v104.0, v104.1);
                                                                                                let v781 = constructor_bor(ctx, v2.0, v243, v140.0);
                                                                                                // Rule at src/opts/bitops.isle line 390.
                                                                                                returns.extend(Some(v781));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v244 = constructor_bxor(ctx, v2.0, v104.1, v104.0);
                                                                                                let v789 = constructor_bor(ctx, v2.0, v244, v140.0);
                                                                                                // Rule at src/opts/bitops.isle line 395.
                                                                                                returns.extend(Some(v789));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let mut v279 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v140.0, &mut v279);
                                                                        let mut v279 = v279.into_context_iter();
                                                                        while let Some(v280) = v279.next(ctx) {
                                                                            if let &InstructionData::Binary {
                                                                                opcode: ref v283,
                                                                                args: ref v284,
                                                                            } = &v280.1 {
                                                                                if let &Opcode::Bxor = v283 {
                                                                                    if v2.0 == v280.0 {
                                                                                        let v285 = C::unpack_value_array_2(ctx, v284);
                                                                                        if v104.0 == v285.0 {
                                                                                            if v104.1 == v285.1 {
                                                                                                let v243 = constructor_bxor(ctx, v2.0, v104.0, v104.1);
                                                                                                let v778 = constructor_bor(ctx, v2.0, v243, v140.1);
                                                                                                // Rule at src/opts/bitops.isle line 383.
                                                                                                returns.extend(Some(v778));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v244 = constructor_bxor(ctx, v2.0, v104.1, v104.0);
                                                                                                let v788 = constructor_bor(ctx, v2.0, v244, v140.1);
                                                                                                // Rule at src/opts/bitops.isle line 398.
                                                                                                returns.extend(Some(v788));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                        if v104.1 == v285.0 {
                                                                                            if v104.0 == v285.1 {
                                                                                                let v243 = constructor_bxor(ctx, v2.0, v104.0, v104.1);
                                                                                                let v778 = constructor_bor(ctx, v2.0, v243, v140.1);
                                                                                                // Rule at src/opts/bitops.isle line 388.
                                                                                                returns.extend(Some(v778));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v244 = constructor_bxor(ctx, v2.0, v104.1, v104.0);
                                                                                                let v788 = constructor_bor(ctx, v2.0, v244, v140.1);
                                                                                                // Rule at src/opts/bitops.isle line 393.
                                                                                                returns.extend(Some(v788));
                                                                                                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 v833 = constructor_band(ctx, v2.0, v140.1, v30);
                                                                        let v834 = constructor_bnot(ctx, v2.0, v833);
                                                                        // Rule at src/opts/bitops.isle line 487.
                                                                        returns.extend(Some(v834));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v30 == v140.1 {
                                                                        let v830 = constructor_band(ctx, v2.0, v140.0, v30);
                                                                        let v831 = constructor_bnot(ctx, v2.0, v830);
                                                                        // Rule at src/opts/bitops.isle line 485.
                                                                        returns.extend(Some(v831));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let v140 = C::unpack_value_array_2(ctx, v139);
                                                let mut v263 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v140.1, &mut v263);
                                                let mut v263 = v263.into_context_iter();
                                                while let Some(v264) = v263.next(ctx) {
                                                    match &v264.1 {
                                                        &InstructionData::Binary {
                                                            opcode: ref v267,
                                                            args: ref v268,
                                                        } => {
                                                            match v267 {
                                                                &Opcode::Band => {
                                                                    if v2.0 == v264.0 {
                                                                        let v269 = C::unpack_value_array_2(ctx, v268);
                                                                        if v7.0 == v269.0 {
                                                                            let v355 = constructor_bor(ctx, v2.0, v140.0, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 517.
                                                                            returns.extend(Some(v355));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.0 == v269.1 {
                                                                            let v355 = constructor_bor(ctx, v2.0, v140.0, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 521.
                                                                            returns.extend(Some(v355));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Bxor => {
                                                                    if v2.0 == v264.0 {
                                                                        let v269 = C::unpack_value_array_2(ctx, v268);
                                                                        if v7.0 == v269.0 {
                                                                            let v719 = constructor_bxor(ctx, v2.0, v269.1, v140.0);
                                                                            let v720 = constructor_bor(ctx, v2.0, v719, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 296.
                                                                            returns.extend(Some(v720));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.0 == v269.1 {
                                                                            let v727 = constructor_bxor(ctx, v2.0, v269.0, v140.0);
                                                                            let v728 = constructor_bor(ctx, v2.0, v727, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 300.
                                                                            returns.extend(Some(v728));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v632,
                                                            arg: v633,
                                                        } => {
                                                            if let &Opcode::Bnot = v632 {
                                                                if v7.0 == v633 {
                                                                    if v2.0 == v264.0 {
                                                                        let v752 = constructor_bnot(ctx, v2.0, v140.0);
                                                                        let v891 = constructor_bor(ctx, v2.0, v7.0, v752);
                                                                        // Rule at src/opts/bitops.isle line 598.
                                                                        returns.extend(Some(v891));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let mut v279 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v140.0, &mut v279);
                                                let mut v279 = v279.into_context_iter();
                                                while let Some(v280) = v279.next(ctx) {
                                                    match &v280.1 {
                                                        &InstructionData::Binary {
                                                            opcode: ref v283,
                                                            args: ref v284,
                                                        } => {
                                                            match v283 {
                                                                &Opcode::Band => {
                                                                    if v2.0 == v280.0 {
                                                                        let v285 = C::unpack_value_array_2(ctx, v284);
                                                                        if v7.0 == v285.0 {
                                                                            let v867 = constructor_bor(ctx, v2.0, v140.1, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 519.
                                                                            returns.extend(Some(v867));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.0 == v285.1 {
                                                                            let v867 = constructor_bor(ctx, v2.0, v140.1, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 523.
                                                                            returns.extend(Some(v867));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Bxor => {
                                                                    if v2.0 == v280.0 {
                                                                        let v285 = C::unpack_value_array_2(ctx, v284);
                                                                        if v7.0 == v285.0 {
                                                                            let v715 = constructor_bxor(ctx, v2.0, v285.1, v140.1);
                                                                            let v716 = constructor_bor(ctx, v2.0, v715, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 294.
                                                                            returns.extend(Some(v716));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.0 == v285.1 {
                                                                            let v723 = constructor_bxor(ctx, v2.0, v285.0, v140.1);
                                                                            let v724 = constructor_bor(ctx, v2.0, v723, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 298.
                                                                            returns.extend(Some(v724));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v635,
                                                            arg: v636,
                                                        } => {
                                                            if let &Opcode::Bnot = v635 {
                                                                if v7.0 == v636 {
                                                                    if v2.0 == v280.0 {
                                                                        let v749 = constructor_bnot(ctx, v2.0, v140.1);
                                                                        let v889 = constructor_bor(ctx, v2.0, v7.0, v749);
                                                                        // Rule at src/opts/bitops.isle line 596.
                                                                        returns.extend(Some(v889));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                if v7.0 == v140.0 {
                                                    let v627 = constructor_bor(ctx, v2.0, v7.0, v140.1);
                                                    // Rule at src/opts/bitops.isle line 404.
                                                    returns.extend(Some(v627));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.0 == v140.1 {
                                                    let v790 = constructor_bor(ctx, v2.0, v7.0, v140.0);
                                                    // Rule at src/opts/bitops.isle line 406.
                                                    returns.extend(Some(v790));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        &Opcode::Ishl => {
                                            let v344 = C::ty_int(ctx, v2.0);
                                            if let Some(v345) = v344 {
                                                if v11.0 == v345 {
                                                    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 v263 = C::inst_data_value_etor_returns::default();
                                                                                    C::inst_data_value_etor(ctx, v140.1, &mut v263);
                                                                                    let mut v263 = v263.into_context_iter();
                                                                                    while let Some(v264) = v263.next(ctx) {
                                                                                        if let &InstructionData::UnaryImm {
                                                                                            opcode: ref v1129,
                                                                                            imm: v1130,
                                                                                        } = &v264.1 {
                                                                                            if let &Opcode::Iconst = v1129 {
                                                                                                let v356 = C::u64_from_imm64(ctx, v133);
                                                                                                let v1894 = C::lane_type(ctx, v345);
                                                                                                let v1895 = C::ty_bits_u64(ctx, v1894);
                                                                                                let v1398 = C::u64_from_imm64(ctx, v1130);
                                                                                                let v1899 = C::u64_wrapping_sub(ctx, v1895, v1398);
                                                                                                let v1900 = C::u64_eq(ctx, v356, v1899);
                                                                                                if v1900 == true {
                                                                                                    let v1901 = constructor_rotl(ctx, v345, v104.0, v140.1);
                                                                                                    // Rule at src/opts/shifts.isle line 284.
                                                                                                    returns.extend(Some(v1901));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Ushr => {
                                            let v344 = C::ty_int(ctx, v2.0);
                                            if let Some(v345) = v344 {
                                                if v11.0 == v345 {
                                                    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 v263 = C::inst_data_value_etor_returns::default();
                                                                                    C::inst_data_value_etor(ctx, v140.1, &mut v263);
                                                                                    let mut v263 = v263.into_context_iter();
                                                                                    while let Some(v264) = v263.next(ctx) {
                                                                                        if let &InstructionData::UnaryImm {
                                                                                            opcode: ref v1129,
                                                                                            imm: v1130,
                                                                                        } = &v264.1 {
                                                                                            if let &Opcode::Iconst = v1129 {
                                                                                                let v1398 = C::u64_from_imm64(ctx, v1130);
                                                                                                let v1894 = C::lane_type(ctx, v345);
                                                                                                let v1895 = C::ty_bits_u64(ctx, v1894);
                                                                                                let v356 = C::u64_from_imm64(ctx, v133);
                                                                                                let v1896 = C::u64_wrapping_sub(ctx, v1895, v356);
                                                                                                let v1897 = C::u64_eq(ctx, v1398, v1896);
                                                                                                if v1897 == true {
                                                                                                    let v1898 = constructor_rotl(ctx, v345, v104.0, v104.1);
                                                                                                    // Rule at src/opts/shifts.isle line 279.
                                                                                                    returns.extend(Some(v1898));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::IntCompare {
                                    opcode: ref v760,
                                    args: ref v761,
                                    cond: ref v762,
                                } => {
                                    if let &Opcode::Icmp = v760 {
                                        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 v754,
                                                args: ref v755,
                                                cond: ref v756,
                                            } = &v19.1 {
                                                if let &Opcode::Icmp = v754 {
                                                    if v11.0 == v19.0 {
                                                        match v756 {
                                                            &IntCC::Equal => {
                                                                match v762 {
                                                                    &IntCC::SignedGreaterThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v757 = C::unpack_value_array_2(ctx, v755);
                                                                            let v763 = C::unpack_value_array_2(ctx, v761);
                                                                            if v757.0 == v763.0 {
                                                                                if v757.1 == v763.1 {
                                                                                    let v777 = constructor_sle(ctx, v2.0, v757.1, v757.0);
                                                                                    // Rule at src/opts/bitops.isle line 380.
                                                                                    returns.extend(Some(v777));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                            if v757.0 == v763.1 {
                                                                                if v757.1 == v763.0 {
                                                                                    let v776 = constructor_sle(ctx, v2.0, v757.0, v757.1);
                                                                                    // Rule at src/opts/bitops.isle line 378.
                                                                                    returns.extend(Some(v776));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedLessThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v757 = C::unpack_value_array_2(ctx, v755);
                                                                            let v763 = C::unpack_value_array_2(ctx, v761);
                                                                            if v757.0 == v763.0 {
                                                                                if v757.1 == v763.1 {
                                                                                    let v776 = constructor_sle(ctx, v2.0, v757.0, v757.1);
                                                                                    // Rule at src/opts/bitops.isle line 372.
                                                                                    returns.extend(Some(v776));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                            if v757.0 == v763.1 {
                                                                                if v757.1 == v763.0 {
                                                                                    let v777 = constructor_sle(ctx, v2.0, v757.1, v757.0);
                                                                                    // Rule at src/opts/bitops.isle line 374.
                                                                                    returns.extend(Some(v777));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedGreaterThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v757 = C::unpack_value_array_2(ctx, v755);
                                                                            let v763 = C::unpack_value_array_2(ctx, v761);
                                                                            if v757.0 == v763.0 {
                                                                                if v757.1 == v763.1 {
                                                                                    let v775 = constructor_ule(ctx, v2.0, v757.1, v757.0);
                                                                                    // Rule at src/opts/bitops.isle line 368.
                                                                                    returns.extend(Some(v775));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                            if v757.0 == v763.1 {
                                                                                if v757.1 == v763.0 {
                                                                                    let v774 = constructor_ule(ctx, v2.0, v757.0, v757.1);
                                                                                    // Rule at src/opts/bitops.isle line 366.
                                                                                    returns.extend(Some(v774));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v757 = C::unpack_value_array_2(ctx, v755);
                                                                            let v763 = C::unpack_value_array_2(ctx, v761);
                                                                            if v757.0 == v763.0 {
                                                                                if v757.1 == v763.1 {
                                                                                    let v774 = constructor_ule(ctx, v2.0, v757.0, v757.1);
                                                                                    // Rule at src/opts/bitops.isle line 360.
                                                                                    returns.extend(Some(v774));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                            if v757.0 == v763.1 {
                                                                                if v757.1 == v763.0 {
                                                                                    let v775 = constructor_ule(ctx, v2.0, v757.1, v757.0);
                                                                                    // Rule at src/opts/bitops.isle line 362.
                                                                                    returns.extend(Some(v775));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                            &IntCC::SignedGreaterThan => {
                                                                match v762 {
                                                                    &IntCC::Equal => {
                                                                        if v2.0 == v11.0 {
                                                                            let v757 = C::unpack_value_array_2(ctx, v755);
                                                                            let v763 = C::unpack_value_array_2(ctx, v761);
                                                                            if v757.0 == v763.0 {
                                                                                if v757.1 == v763.1 {
                                                                                    let v777 = constructor_sle(ctx, v2.0, v757.1, v757.0);
                                                                                    // Rule at src/opts/bitops.isle line 379.
                                                                                    returns.extend(Some(v777));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                            if v757.0 == v763.1 {
                                                                                if v757.1 == v763.0 {
                                                                                    let v777 = constructor_sle(ctx, v2.0, v757.1, v757.0);
                                                                                    // Rule at src/opts/bitops.isle line 377.
                                                                                    returns.extend(Some(v777));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedGreaterThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v757 = C::unpack_value_array_2(ctx, v755);
                                                                            let v763 = C::unpack_value_array_2(ctx, v761);
                                                                            if v757.0 == v763.1 {
                                                                                if v757.1 == v763.0 {
                                                                                    let v767 = constructor_ne(ctx, v2.0, v757.1, v757.0);
                                                                                    // Rule at src/opts/bitops.isle line 335.
                                                                                    returns.extend(Some(v767));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    let v766 = constructor_ne(ctx, v2.0, v757.0, v757.1);
                                                                                    // Rule at src/opts/bitops.isle line 336.
                                                                                    returns.extend(Some(v766));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedLessThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v757 = C::unpack_value_array_2(ctx, v755);
                                                                            let v763 = C::unpack_value_array_2(ctx, v761);
                                                                            if v757.0 == v763.0 {
                                                                                if v757.1 == v763.1 {
                                                                                    let v766 = constructor_ne(ctx, v2.0, v757.0, v757.1);
                                                                                    // Rule at src/opts/bitops.isle line 332.
                                                                                    returns.extend(Some(v766));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    let v767 = constructor_ne(ctx, v2.0, v757.1, v757.0);
                                                                                    // Rule at src/opts/bitops.isle line 337.
                                                                                    returns.extend(Some(v767));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                            &IntCC::SignedLessThan => {
                                                                match v762 {
                                                                    &IntCC::Equal => {
                                                                        if v2.0 == v11.0 {
                                                                            let v757 = C::unpack_value_array_2(ctx, v755);
                                                                            let v763 = C::unpack_value_array_2(ctx, v761);
                                                                            if v757.0 == v763.0 {
                                                                                if v757.1 == v763.1 {
                                                                                    let v776 = constructor_sle(ctx, v2.0, v757.0, v757.1);
                                                                                    // Rule at src/opts/bitops.isle line 371.
                                                                                    returns.extend(Some(v776));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                            if v757.0 == v763.1 {
                                                                                if v757.1 == v763.0 {
                                                                                    let v776 = constructor_sle(ctx, v2.0, v757.0, v757.1);
                                                                                    // Rule at src/opts/bitops.isle line 373.
                                                                                    returns.extend(Some(v776));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedGreaterThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v757 = C::unpack_value_array_2(ctx, v755);
                                                                            let v763 = C::unpack_value_array_2(ctx, v761);
                                                                            if v757.0 == v763.0 {
                                                                                if v757.1 == v763.1 {
                                                                                    let v766 = constructor_ne(ctx, v2.0, v757.0, v757.1);
                                                                                    // Rule at src/opts/bitops.isle line 331.
                                                                                    returns.extend(Some(v766));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    let v767 = constructor_ne(ctx, v2.0, v757.1, v757.0);
                                                                                    // Rule at src/opts/bitops.isle line 338.
                                                                                    returns.extend(Some(v767));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedLessThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v757 = C::unpack_value_array_2(ctx, v755);
                                                                            let v763 = C::unpack_value_array_2(ctx, v761);
                                                                            if v757.0 == v763.1 {
                                                                                if v757.1 == v763.0 {
                                                                                    let v766 = constructor_ne(ctx, v2.0, v757.0, v757.1);
                                                                                    // Rule at src/opts/bitops.isle line 333.
                                                                                    returns.extend(Some(v766));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    let v767 = constructor_ne(ctx, v2.0, v757.1, v757.0);
                                                                                    // Rule at src/opts/bitops.isle line 334.
                                                                                    returns.extend(Some(v767));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                            &IntCC::UnsignedGreaterThan => {
                                                                match v762 {
                                                                    &IntCC::Equal => {
                                                                        if v2.0 == v11.0 {
                                                                            let v757 = C::unpack_value_array_2(ctx, v755);
                                                                            let v763 = C::unpack_value_array_2(ctx, v761);
                                                                            if v757.0 == v763.0 {
                                                                                if v757.1 == v763.1 {
                                                                                    let v775 = constructor_ule(ctx, v2.0, v757.1, v757.0);
                                                                                    // Rule at src/opts/bitops.isle line 367.
                                                                                    returns.extend(Some(v775));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                            if v757.0 == v763.1 {
                                                                                if v757.1 == v763.0 {
                                                                                    let v775 = constructor_ule(ctx, v2.0, v757.1, v757.0);
                                                                                    // Rule at src/opts/bitops.isle line 365.
                                                                                    returns.extend(Some(v775));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedGreaterThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v757 = C::unpack_value_array_2(ctx, v755);
                                                                            let v763 = C::unpack_value_array_2(ctx, v761);
                                                                            if v757.0 == v763.1 {
                                                                                if v757.1 == v763.0 {
                                                                                    let v767 = constructor_ne(ctx, v2.0, v757.1, v757.0);
                                                                                    // Rule at src/opts/bitops.isle line 345.
                                                                                    returns.extend(Some(v767));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    let v766 = constructor_ne(ctx, v2.0, v757.0, v757.1);
                                                                                    // Rule at src/opts/bitops.isle line 346.
                                                                                    returns.extend(Some(v766));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v757 = C::unpack_value_array_2(ctx, v755);
                                                                            let v763 = C::unpack_value_array_2(ctx, v761);
                                                                            if v757.0 == v763.0 {
                                                                                if v757.1 == v763.1 {
                                                                                    let v766 = constructor_ne(ctx, v2.0, v757.0, v757.1);
                                                                                    // Rule at src/opts/bitops.isle line 342.
                                                                                    returns.extend(Some(v766));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    let v767 = constructor_ne(ctx, v2.0, v757.1, v757.0);
                                                                                    // Rule at src/opts/bitops.isle line 347.
                                                                                    returns.extend(Some(v767));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                            &IntCC::UnsignedLessThan => {
                                                                match v762 {
                                                                    &IntCC::Equal => {
                                                                        if v2.0 == v11.0 {
                                                                            let v757 = C::unpack_value_array_2(ctx, v755);
                                                                            let v763 = C::unpack_value_array_2(ctx, v761);
                                                                            if v757.0 == v763.0 {
                                                                                if v757.1 == v763.1 {
                                                                                    let v774 = constructor_ule(ctx, v2.0, v757.0, v757.1);
                                                                                    // Rule at src/opts/bitops.isle line 359.
                                                                                    returns.extend(Some(v774));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                            if v757.0 == v763.1 {
                                                                                if v757.1 == v763.0 {
                                                                                    let v774 = constructor_ule(ctx, v2.0, v757.0, v757.1);
                                                                                    // Rule at src/opts/bitops.isle line 361.
                                                                                    returns.extend(Some(v774));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedGreaterThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v757 = C::unpack_value_array_2(ctx, v755);
                                                                            let v763 = C::unpack_value_array_2(ctx, v761);
                                                                            if v757.0 == v763.0 {
                                                                                if v757.1 == v763.1 {
                                                                                    let v766 = constructor_ne(ctx, v2.0, v757.0, v757.1);
                                                                                    // Rule at src/opts/bitops.isle line 341.
                                                                                    returns.extend(Some(v766));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    let v767 = constructor_ne(ctx, v2.0, v757.1, v757.0);
                                                                                    // Rule at src/opts/bitops.isle line 348.
                                                                                    returns.extend(Some(v767));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v757 = C::unpack_value_array_2(ctx, v755);
                                                                            let v763 = C::unpack_value_array_2(ctx, v761);
                                                                            if v757.0 == v763.1 {
                                                                                if v757.1 == v763.0 {
                                                                                    let v766 = constructor_ne(ctx, v2.0, v757.0, v757.1);
                                                                                    // Rule at src/opts/bitops.isle line 343.
                                                                                    returns.extend(Some(v766));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    let v767 = constructor_ne(ctx, v2.0, v757.1, v757.0);
                                                                                    // Rule at src/opts/bitops.isle line 344.
                                                                                    returns.extend(Some(v767));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                        let v339 = C::fits_in_64(ctx, v2.0);
                                                        if let Some(v340) = v339 {
                                                            if v11.0 == v340 {
                                                                let v1470 = constructor_intcc_comparable(ctx, v756, v762);
                                                                if let Some(v1471) = v1470 {
                                                                    let v757 = C::unpack_value_array_2(ctx, v755);
                                                                    let v763 = C::unpack_value_array_2(ctx, v761);
                                                                    if v757.0 == v763.0 {
                                                                        if v757.1 == v763.1 {
                                                                            let v1472 = constructor_decompose_intcc(ctx, v756);
                                                                            let v1473 = constructor_decompose_intcc(ctx, v762);
                                                                            let v1476 = C::u64_or(ctx, v1472, v1473);
                                                                            let v1477 = constructor_compose_icmp(ctx, v340, v1476, v1471, v757.0, v757.1);
                                                                            // Rule at src/opts/icmp.isle line 183.
                                                                            returns.extend(Some(v1477));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v26,
                                    arg: v27,
                                } => {
                                    match v26 {
                                        &Opcode::Splat => {
                                            let v1990 = C::ty_vector_not_float(ctx, v2.0);
                                            if let Some(v1991) = v1990 {
                                                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 v1854 = C::lane_type(ctx, v2.0);
                                                                    let v1994 = constructor_bor(ctx, v1854, v30, v27);
                                                                    let v1995 = constructor_splat(ctx, v2.0, v1994);
                                                                    // Rule at src/opts/vector.isle line 18.
                                                                    returns.extend(Some(v1995));
                                                                    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 v644 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v27, &mut v644);
                                                                        let mut v644 = v644.into_context_iter();
                                                                        while let Some(v645) = v644.next(ctx) {
                                                                            if let &InstructionData::Binary {
                                                                                opcode: ref v648,
                                                                                args: ref v649,
                                                                            } = &v645.1 {
                                                                                match v648 {
                                                                                    &Opcode::Bor => {
                                                                                        if v2.0 == v645.0 {
                                                                                            let v104 = C::unpack_value_array_2(ctx, v103);
                                                                                            let v650 = C::unpack_value_array_2(ctx, v649);
                                                                                            if v104.0 == v650.0 {
                                                                                                if v104.1 == v650.1 {
                                                                                                    let v243 = constructor_bxor(ctx, v2.0, v104.0, v104.1);
                                                                                                    let v653 = constructor_bnot(ctx, v2.0, v243);
                                                                                                    // Rule at src/opts/bitops.isle line 671.
                                                                                                    returns.extend(Some(v653));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    let v244 = constructor_bxor(ctx, v2.0, v104.1, v104.0);
                                                                                                    let v667 = constructor_bnot(ctx, v2.0, v244);
                                                                                                    // Rule at src/opts/bitops.isle line 677.
                                                                                                    returns.extend(Some(v667));
                                                                                                    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 == v650.1 {
                                                                                                                if v2.0 == v115.0 {
                                                                                                                    let v931 = constructor_bnot(ctx, v2.0, v119);
                                                                                                                    // Rule at src/opts/bitops.isle line 657.
                                                                                                                    returns.extend(Some(v931));
                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                            if v104.0 == v650.1 {
                                                                                                if v104.1 == v650.0 {
                                                                                                    let v243 = constructor_bxor(ctx, v2.0, v104.0, v104.1);
                                                                                                    let v653 = constructor_bnot(ctx, v2.0, v243);
                                                                                                    // Rule at src/opts/bitops.isle line 673.
                                                                                                    returns.extend(Some(v653));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    let v244 = constructor_bxor(ctx, v2.0, v104.1, v104.0);
                                                                                                    let v667 = constructor_bnot(ctx, v2.0, v244);
                                                                                                    // Rule at src/opts/bitops.isle line 675.
                                                                                                    returns.extend(Some(v667));
                                                                                                    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 == v650.0 {
                                                                                                                if v2.0 == v115.0 {
                                                                                                                    let v931 = constructor_bnot(ctx, v2.0, v119);
                                                                                                                    // Rule at src/opts/bitops.isle line 655.
                                                                                                                    returns.extend(Some(v931));
                                                                                                                    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 == v650.0 {
                                                                                                                if v104.1 == v650.1 {
                                                                                                                    let v930 = constructor_bnot(ctx, v2.0, v112);
                                                                                                                    // Rule at src/opts/bitops.isle line 651.
                                                                                                                    returns.extend(Some(v930));
                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                }
                                                                                                            }
                                                                                                            if v112 == v650.1 {
                                                                                                                if v104.1 == v650.0 {
                                                                                                                    let v930 = constructor_bnot(ctx, v2.0, v112);
                                                                                                                    // Rule at src/opts/bitops.isle line 653.
                                                                                                                    returns.extend(Some(v930));
                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                    &Opcode::Bxor => {
                                                                                        if v2.0 == v645.0 {
                                                                                            let v104 = C::unpack_value_array_2(ctx, v103);
                                                                                            let v650 = C::unpack_value_array_2(ctx, v649);
                                                                                            if v104.0 == v650.0 {
                                                                                                if v104.1 == v650.1 {
                                                                                                    let v243 = constructor_bxor(ctx, v2.0, v104.0, v104.1);
                                                                                                    let v653 = constructor_bnot(ctx, v2.0, v243);
                                                                                                    // Rule at src/opts/bitops.isle line 229.
                                                                                                    returns.extend(Some(v653));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    let v244 = constructor_bxor(ctx, v2.0, v104.1, v104.0);
                                                                                                    let v667 = constructor_bnot(ctx, v2.0, v244);
                                                                                                    // Rule at src/opts/bitops.isle line 235.
                                                                                                    returns.extend(Some(v667));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                            if v104.0 == v650.1 {
                                                                                                if v104.1 == v650.0 {
                                                                                                    let v243 = constructor_bxor(ctx, v2.0, v104.0, v104.1);
                                                                                                    let v653 = constructor_bnot(ctx, v2.0, v243);
                                                                                                    // Rule at src/opts/bitops.isle line 231.
                                                                                                    returns.extend(Some(v653));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    let v244 = constructor_bxor(ctx, v2.0, v104.1, v104.0);
                                                                                                    let v667 = constructor_bnot(ctx, v2.0, v244);
                                                                                                    // Rule at src/opts/bitops.isle line 233.
                                                                                                    returns.extend(Some(v667));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                    _ => {}
                                                                                }
                                                                            }
                                                                        }
                                                                        let v104 = C::unpack_value_array_2(ctx, v103);
                                                                        if v27 == v104.0 {
                                                                            let v638 = constructor_bnot(ctx, v2.0, v104.0);
                                                                            let v639 = constructor_bor(ctx, v2.0, v104.1, v638);
                                                                            // Rule at src/opts/bitops.isle line 220.
                                                                            returns.extend(Some(v639));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v27 == v104.1 {
                                                                            let v354 = constructor_bor(ctx, v2.0, v104.0, v7.1);
                                                                            // Rule at src/opts/bitops.isle line 44.
                                                                            returns.extend(Some(v354));
                                                                            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 v832 = constructor_bnot(ctx, v2.0, v247);
                                                                            // Rule at src/opts/bitops.isle line 486.
                                                                            returns.extend(Some(v832));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v27 == v104.1 {
                                                                            let v143 = constructor_band(ctx, v2.0, v104.0, v104.1);
                                                                            let v829 = constructor_bnot(ctx, v2.0, v143);
                                                                            // Rule at src/opts/bitops.isle line 484.
                                                                            returns.extend(Some(v829));
                                                                            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 v709 = constructor_band(ctx, v2.0, v30, v27);
                                                                    let v710 = constructor_bnot(ctx, v2.0, v709);
                                                                    // Rule at src/opts/bitops.isle line 289.
                                                                    returns.extend(Some(v710));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    let v711 = constructor_band(ctx, v2.0, v27, v30);
                                                                    let v712 = constructor_bnot(ctx, v2.0, v711);
                                                                    // Rule at src/opts/bitops.isle line 290.
                                                                    returns.extend(Some(v712));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let mut v644 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v27, &mut v644);
                                                let mut v644 = v644.into_context_iter();
                                                while let Some(v645) = v644.next(ctx) {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v648,
                                                        args: ref v649,
                                                    } = &v645.1 {
                                                        match v648 {
                                                            &Opcode::Bor => {
                                                                if v2.0 == v645.0 {
                                                                    let v650 = C::unpack_value_array_2(ctx, v649);
                                                                    if v7.0 == v650.0 {
                                                                        let v741 = constructor_bnot(ctx, v2.0, v650.1);
                                                                        let v742 = constructor_bor(ctx, v2.0, v7.0, v741);
                                                                        // Rule at src/opts/bitops.isle line 315.
                                                                        returns.extend(Some(v742));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v7.0 == v650.1 {
                                                                        let v737 = constructor_bnot(ctx, v2.0, v650.0);
                                                                        let v738 = constructor_bor(ctx, v2.0, v7.0, v737);
                                                                        // Rule at src/opts/bitops.isle line 313.
                                                                        returns.extend(Some(v738));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Bxor => {
                                                                if v2.0 == v645.0 {
                                                                    let v650 = C::unpack_value_array_2(ctx, v649);
                                                                    if v7.0 == v650.0 {
                                                                        let v741 = constructor_bnot(ctx, v2.0, v650.1);
                                                                        let v742 = constructor_bor(ctx, v2.0, v7.0, v741);
                                                                        // Rule at src/opts/bitops.isle line 590.
                                                                        returns.extend(Some(v742));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v7.0 == v650.1 {
                                                                        let v737 = constructor_bnot(ctx, v2.0, v650.0);
                                                                        let v738 = constructor_bor(ctx, v2.0, v7.0, v737);
                                                                        // Rule at src/opts/bitops.isle line 592.
                                                                        returns.extend(Some(v738));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                    }
                                                }
                                            }
                                            let v348 = C::ty_int_vec128(ctx, v2.0);
                                            if let Some(v349) = v348 {
                                                if v11.0 == v349 {
                                                    if v7.0 == v27 {
                                                        let v350 = constructor_iconst_s(ctx, v349, -1_i64);
                                                        let v351 = C::subsume(ctx, v350);
                                                        // Rule at src/opts/bitops.isle line 24.
                                                        returns.extend(Some(v351));
                                                        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 v1347 = C::value_type(ctx, v30);
                                                        let v1378 = C::value_type(ctx, v27);
                                                        if v1347 == v1378 {
                                                            let v1381 = constructor_bor(ctx, v1347, v30, v27);
                                                            let v1382 = constructor_uextend(ctx, v2.0, v1381);
                                                            // Rule at src/opts/extends.isle line 72.
                                                            returns.extend(Some(v1382));
                                                            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 v357 = C::ty_mask(ctx, v2.0);
                                                                            let v16 = C::u64_from_imm64(ctx, v15);
                                                                            let v358 = C::u64_and(ctx, v357, v16);
                                                                            let v356 = C::u64_from_imm64(ctx, v133);
                                                                            let v359 = C::u64_not(ctx, v356);
                                                                            let v360 = C::u64_and(ctx, v357, v359);
                                                                            let v361 = C::u64_eq(ctx, v358, v360);
                                                                            if v361 == true {
                                                                                if v2.0 == v115.0 {
                                                                                    let v354 = constructor_bor(ctx, v2.0, v104.0, v7.1);
                                                                                    // Rule at src/opts/bitops.isle line 64.
                                                                                    returns.extend(Some(v354));
                                                                                    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 v1056 = constructor_bor(ctx, v2.0, v104.1, v7.1);
                                                                                let v1057 = constructor_bor(ctx, v2.0, v104.0, v1056);
                                                                                // Rule at src/opts/cprop.isle line 216.
                                                                                returns.extend(Some(v1057));
                                                                                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 v339 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v340) = v339 {
                                            if v11.0 == v340 {
                                                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 v966 = C::imm64_or(ctx, v340, v23, v15);
                                                                let v967 = constructor_iconst(ctx, v340, v966);
                                                                let v968 = C::subsume(ctx, v967);
                                                                // Rule at src/opts/cprop.isle line 55.
                                                                returns.extend(Some(v968));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        let v1610 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 17.
                                        returns.extend(Some(v1610));
                                        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 v289,
                                                            args: ref v290,
                                                        } => {
                                                            match v289 {
                                                                &Opcode::Bor => {
                                                                    if v2.0 == v108.0 {
                                                                        let v291 = C::unpack_value_array_2(ctx, v290);
                                                                        if v7.1 == v291.0 {
                                                                            let v839 = constructor_band(ctx, v2.0, v104.1, v291.1);
                                                                            let v840 = constructor_bor(ctx, v2.0, v839, v291.0);
                                                                            // Rule at src/opts/bitops.isle line 498.
                                                                            returns.extend(Some(v840));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.1 == v291.1 {
                                                                            let v847 = constructor_band(ctx, v2.0, v104.1, v291.0);
                                                                            let v848 = constructor_bor(ctx, v2.0, v847, v291.1);
                                                                            // Rule at src/opts/bitops.isle line 502.
                                                                            returns.extend(Some(v848));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Bxor => {
                                                                    if v2.0 == v108.0 {
                                                                        let v291 = C::unpack_value_array_2(ctx, v290);
                                                                        if v7.1 == v291.0 {
                                                                            let v809 = constructor_band(ctx, v2.0, v291.1, v104.1);
                                                                            let v810 = constructor_bor(ctx, v2.0, v809, v291.0);
                                                                            // Rule at src/opts/bitops.isle line 438.
                                                                            returns.extend(Some(v810));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.1 == v291.1 {
                                                                            let v801 = constructor_band(ctx, v2.0, v291.0, v104.1);
                                                                            let v802 = constructor_bor(ctx, v2.0, v801, v291.1);
                                                                            // Rule at src/opts/bitops.isle line 434.
                                                                            returns.extend(Some(v802));
                                                                            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 v871 = constructor_bor(ctx, v2.0, v112, v104.1);
                                                                        // Rule at src/opts/bitops.isle line 533.
                                                                        returns.extend(Some(v871));
                                                                        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 v273,
                                                            args: ref v274,
                                                        } => {
                                                            match v273 {
                                                                &Opcode::Bor => {
                                                                    if v2.0 == v115.0 {
                                                                        let v275 = C::unpack_value_array_2(ctx, v274);
                                                                        if v7.1 == v275.0 {
                                                                            let v835 = constructor_band(ctx, v2.0, v104.0, v275.1);
                                                                            let v836 = constructor_bor(ctx, v2.0, v835, v275.0);
                                                                            // Rule at src/opts/bitops.isle line 496.
                                                                            returns.extend(Some(v836));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.1 == v275.1 {
                                                                            let v843 = constructor_band(ctx, v2.0, v104.0, v275.0);
                                                                            let v844 = constructor_bor(ctx, v2.0, v843, v275.1);
                                                                            // Rule at src/opts/bitops.isle line 500.
                                                                            returns.extend(Some(v844));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Bxor => {
                                                                    if v2.0 == v115.0 {
                                                                        let v275 = C::unpack_value_array_2(ctx, v274);
                                                                        if v7.1 == v275.0 {
                                                                            let v813 = constructor_band(ctx, v2.0, v275.1, v104.0);
                                                                            let v814 = constructor_bor(ctx, v2.0, v813, v275.0);
                                                                            // Rule at src/opts/bitops.isle line 440.
                                                                            returns.extend(Some(v814));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.1 == v275.1 {
                                                                            let v805 = constructor_band(ctx, v2.0, v275.0, v104.0);
                                                                            let v806 = constructor_bor(ctx, v2.0, v805, v275.1);
                                                                            // Rule at src/opts/bitops.isle line 436.
                                                                            returns.extend(Some(v806));
                                                                            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 v872 = constructor_bor(ctx, v2.0, v119, v104.0);
                                                                        // Rule at src/opts/bitops.isle line 535.
                                                                        returns.extend(Some(v872));
                                                                        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 v289,
                                                            args: ref v290,
                                                        } => {
                                                            match v289 {
                                                                &Opcode::Band => {
                                                                    if v2.0 == v108.0 {
                                                                        let v291 = C::unpack_value_array_2(ctx, v290);
                                                                        if v7.1 == v291.0 {
                                                                            let v863 = constructor_bor(ctx, v2.0, v104.1, v291.0);
                                                                            // Rule at src/opts/bitops.isle line 518.
                                                                            returns.extend(Some(v863));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.1 == v291.1 {
                                                                            let v855 = constructor_bor(ctx, v2.0, v104.1, v291.1);
                                                                            // Rule at src/opts/bitops.isle line 522.
                                                                            returns.extend(Some(v855));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Bxor => {
                                                                    if v2.0 == v108.0 {
                                                                        let v291 = C::unpack_value_array_2(ctx, v290);
                                                                        if v7.1 == v291.0 {
                                                                            let v713 = constructor_bxor(ctx, v2.0, v291.1, v104.1);
                                                                            let v714 = constructor_bor(ctx, v2.0, v713, v291.0);
                                                                            // Rule at src/opts/bitops.isle line 293.
                                                                            returns.extend(Some(v714));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.1 == v291.1 {
                                                                            let v721 = constructor_bxor(ctx, v2.0, v291.0, v104.1);
                                                                            let v722 = constructor_bor(ctx, v2.0, v721, v291.1);
                                                                            // Rule at src/opts/bitops.isle line 297.
                                                                            returns.extend(Some(v722));
                                                                            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 v668 = constructor_bnot(ctx, v2.0, v104.1);
                                                                        let v890 = constructor_bor(ctx, v2.0, v112, v668);
                                                                        // Rule at src/opts/bitops.isle line 597.
                                                                        returns.extend(Some(v890));
                                                                        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 v273,
                                                            args: ref v274,
                                                        } => {
                                                            match v273 {
                                                                &Opcode::Band => {
                                                                    if v2.0 == v115.0 {
                                                                        let v275 = C::unpack_value_array_2(ctx, v274);
                                                                        if v7.1 == v275.0 {
                                                                            let v859 = constructor_bor(ctx, v2.0, v104.0, v275.0);
                                                                            // Rule at src/opts/bitops.isle line 516.
                                                                            returns.extend(Some(v859));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.1 == v275.1 {
                                                                            let v851 = constructor_bor(ctx, v2.0, v104.0, v275.1);
                                                                            // Rule at src/opts/bitops.isle line 520.
                                                                            returns.extend(Some(v851));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Bxor => {
                                                                    if v2.0 == v115.0 {
                                                                        let v275 = C::unpack_value_array_2(ctx, v274);
                                                                        if v7.1 == v275.0 {
                                                                            let v717 = constructor_bxor(ctx, v2.0, v275.1, v104.0);
                                                                            let v718 = constructor_bor(ctx, v2.0, v717, v275.0);
                                                                            // Rule at src/opts/bitops.isle line 295.
                                                                            returns.extend(Some(v718));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.1 == v275.1 {
                                                                            let v725 = constructor_bxor(ctx, v2.0, v275.0, v104.0);
                                                                            let v726 = constructor_bor(ctx, v2.0, v725, v275.1);
                                                                            // Rule at src/opts/bitops.isle line 299.
                                                                            returns.extend(Some(v726));
                                                                            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 v638 = constructor_bnot(ctx, v2.0, v104.0);
                                                                        let v892 = constructor_bor(ctx, v2.0, v119, v638);
                                                                        // Rule at src/opts/bitops.isle line 599.
                                                                        returns.extend(Some(v892));
                                                                        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 v654 = C::inst_data_value_etor_returns::default();
                                            C::inst_data_value_etor(ctx, v30, &mut v654);
                                            let mut v654 = v654.into_context_iter();
                                            while let Some(v655) = v654.next(ctx) {
                                                if let &InstructionData::Binary {
                                                    opcode: ref v658,
                                                    args: ref v659,
                                                } = &v655.1 {
                                                    match v658 {
                                                        &Opcode::Bor => {
                                                            if v2.0 == v655.0 {
                                                                let v660 = C::unpack_value_array_2(ctx, v659);
                                                                if v7.1 == v660.0 {
                                                                    let v743 = constructor_bnot(ctx, v2.0, v660.1);
                                                                    let v744 = constructor_bor(ctx, v2.0, v660.0, v743);
                                                                    // Rule at src/opts/bitops.isle line 316.
                                                                    returns.extend(Some(v744));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v7.1 == v660.1 {
                                                                    let v739 = constructor_bnot(ctx, v2.0, v660.0);
                                                                    let v740 = constructor_bor(ctx, v2.0, v660.1, v739);
                                                                    // Rule at src/opts/bitops.isle line 314.
                                                                    returns.extend(Some(v740));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                        &Opcode::Bxor => {
                                                            if v2.0 == v655.0 {
                                                                let v660 = C::unpack_value_array_2(ctx, v659);
                                                                if v7.1 == v660.0 {
                                                                    let v743 = constructor_bnot(ctx, v2.0, v660.1);
                                                                    let v744 = constructor_bor(ctx, v2.0, v660.0, v743);
                                                                    // Rule at src/opts/bitops.isle line 591.
                                                                    returns.extend(Some(v744));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v7.1 == v660.1 {
                                                                    let v739 = constructor_bnot(ctx, v2.0, v660.0);
                                                                    let v740 = constructor_bor(ctx, v2.0, v660.1, v739);
                                                                    // Rule at src/opts/bitops.isle line 593.
                                                                    returns.extend(Some(v740));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                            }
                                        }
                                        if v7.1 == v30 {
                                            let v348 = C::ty_int_vec128(ctx, v2.0);
                                            if let Some(v349) = v348 {
                                                if v19.0 == v349 {
                                                    let v350 = constructor_iconst_s(ctx, v349, -1_i64);
                                                    let v351 = C::subsume(ctx, v350);
                                                    // Rule at src/opts/bitops.isle line 25.
                                                    returns.extend(Some(v351));
                                                    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 v1028 = constructor_bor(ctx, v2.0, v7.1, v7.0);
                                            // Rule at src/opts/cprop.isle line 158.
                                            returns.extend(Some(v1028));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        let v1610 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 15.
                                        returns.extend(Some(v1610));
                                        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) {
                                                    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 v140 = C::unpack_value_array_2(ctx, v139);
                                                                        if v104.0 == v140.0 {
                                                                            let v642 = constructor_bxor(ctx, v2.0, v104.1, v140.1);
                                                                            let v643 = constructor_band(ctx, v2.0, v104.0, v642);
                                                                            // Rule at src/opts/bitops.isle line 224.
                                                                            returns.extend(Some(v643));
                                                                            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; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                        &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 mut v263 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v140.1, &mut v263);
                                                                        let mut v263 = v263.into_context_iter();
                                                                        while let Some(v264) = v263.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v632,
                                                                                arg: v633,
                                                                            } = &v264.1 {
                                                                                if let &Opcode::Bnot = v632 {
                                                                                    if v2.0 == v264.0 {
                                                                                        let v882 = constructor_band(ctx, v2.0, v30, v633);
                                                                                        let v883 = constructor_bnot(ctx, v2.0, v882);
                                                                                        // Rule at src/opts/bitops.isle line 569.
                                                                                        returns.extend(Some(v883));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    if v30 == v140.1 {
                                                                        let mut v279 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v140.0, &mut v279);
                                                                        let mut v279 = v279.into_context_iter();
                                                                        while let Some(v280) = v279.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v635,
                                                                                arg: v636,
                                                                            } = &v280.1 {
                                                                                if let &Opcode::Bnot = v635 {
                                                                                    if v2.0 == v280.0 {
                                                                                        let v885 = constructor_band(ctx, v2.0, v30, v636);
                                                                                        let v886 = constructor_bnot(ctx, v2.0, v885);
                                                                                        // Rule at src/opts/bitops.isle line 571.
                                                                                        returns.extend(Some(v886));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let v140 = C::unpack_value_array_2(ctx, v139);
                                                let mut v263 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v140.1, &mut v263);
                                                let mut v263 = v263.into_context_iter();
                                                while let Some(v264) = v263.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v632,
                                                        arg: v633,
                                                    } = &v264.1 {
                                                        if let &Opcode::Bnot = v632 {
                                                            if v2.0 == v264.0 {
                                                                if v7.0 == v633 {
                                                                    let v790 = constructor_bor(ctx, v2.0, v7.0, v140.0);
                                                                    // Rule at src/opts/bitops.isle line 577.
                                                                    returns.extend(Some(v790));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                let v926 = constructor_band(ctx, v2.0, v633, v140.0);
                                                                let v927 = constructor_bxor(ctx, v2.0, v7.0, v140.0);
                                                                let v928 = constructor_bxor(ctx, v2.0, v926, v927);
                                                                // Rule at src/opts/bitops.isle line 645.
                                                                returns.extend(Some(v928));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                                let mut v279 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v140.0, &mut v279);
                                                let mut v279 = v279.into_context_iter();
                                                while let Some(v280) = v279.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v635,
                                                        arg: v636,
                                                    } = &v280.1 {
                                                        if let &Opcode::Bnot = v635 {
                                                            if v2.0 == v280.0 {
                                                                if v7.0 == v636 {
                                                                    let v627 = constructor_bor(ctx, v2.0, v7.0, v140.1);
                                                                    // Rule at src/opts/bitops.isle line 575.
                                                                    returns.extend(Some(v627));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                let v921 = constructor_band(ctx, v2.0, v636, v140.1);
                                                                let v922 = constructor_bxor(ctx, v2.0, v7.0, v140.1);
                                                                let v923 = constructor_bxor(ctx, v2.0, v921, v922);
                                                                // Rule at src/opts/bitops.isle line 643.
                                                                returns.extend(Some(v923));
                                                                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 v638 = constructor_bnot(ctx, v2.0, v104.0);
                                                                                                // Rule at src/opts/bitops.isle line 276.
                                                                                                returns.extend(Some(v638));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            let mut v263 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v140.1, &mut v263);
                                                                            let mut v263 = v263.into_context_iter();
                                                                            while let Some(v264) = v263.next(ctx) {
                                                                                if let &InstructionData::Unary {
                                                                                    opcode: ref v632,
                                                                                    arg: v633,
                                                                                } = &v264.1 {
                                                                                    if let &Opcode::Bnot = v632 {
                                                                                        if v104.1 == v633 {
                                                                                            if v2.0 == v264.0 {
                                                                                                let v638 = constructor_bnot(ctx, v2.0, v104.0);
                                                                                                // Rule at src/opts/bitops.isle line 275.
                                                                                                returns.extend(Some(v638));
                                                                                                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 v638 = constructor_bnot(ctx, v2.0, v104.0);
                                                                                                // Rule at src/opts/bitops.isle line 280.
                                                                                                returns.extend(Some(v638));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            let mut v279 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v140.0, &mut v279);
                                                                            let mut v279 = v279.into_context_iter();
                                                                            while let Some(v280) = v279.next(ctx) {
                                                                                if let &InstructionData::Unary {
                                                                                    opcode: ref v635,
                                                                                    arg: v636,
                                                                                } = &v280.1 {
                                                                                    if let &Opcode::Bnot = v635 {
                                                                                        if v104.1 == v636 {
                                                                                            if v2.0 == v280.0 {
                                                                                                let v638 = constructor_bnot(ctx, v2.0, v104.0);
                                                                                                // Rule at src/opts/bitops.isle line 277.
                                                                                                returns.extend(Some(v638));
                                                                                                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 v668 = constructor_bnot(ctx, v2.0, v104.1);
                                                                                                // Rule at src/opts/bitops.isle line 278.
                                                                                                returns.extend(Some(v668));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            let mut v263 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v140.1, &mut v263);
                                                                            let mut v263 = v263.into_context_iter();
                                                                            while let Some(v264) = v263.next(ctx) {
                                                                                if let &InstructionData::Unary {
                                                                                    opcode: ref v632,
                                                                                    arg: v633,
                                                                                } = &v264.1 {
                                                                                    if let &Opcode::Bnot = v632 {
                                                                                        if v104.0 == v633 {
                                                                                            if v2.0 == v264.0 {
                                                                                                let v668 = constructor_bnot(ctx, v2.0, v104.1);
                                                                                                // Rule at src/opts/bitops.isle line 279.
                                                                                                returns.extend(Some(v668));
                                                                                                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 v668 = constructor_bnot(ctx, v2.0, v104.1);
                                                                                                // Rule at src/opts/bitops.isle line 282.
                                                                                                returns.extend(Some(v668));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            let mut v279 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v140.0, &mut v279);
                                                                            let mut v279 = v279.into_context_iter();
                                                                            while let Some(v280) = v279.next(ctx) {
                                                                                if let &InstructionData::Unary {
                                                                                    opcode: ref v635,
                                                                                    arg: v636,
                                                                                } = &v280.1 {
                                                                                    if let &Opcode::Bnot = v635 {
                                                                                        if v104.0 == v636 {
                                                                                            if v2.0 == v280.0 {
                                                                                                let v668 = constructor_bnot(ctx, v2.0, v104.1);
                                                                                                // Rule at src/opts/bitops.isle line 281.
                                                                                                returns.extend(Some(v668));
                                                                                                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 v263 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v140.1, &mut v263);
                                                                            let mut v263 = v263.into_context_iter();
                                                                            while let Some(v264) = v263.next(ctx) {
                                                                                if let &InstructionData::Unary {
                                                                                    opcode: ref v632,
                                                                                    arg: v633,
                                                                                } = &v264.1 {
                                                                                    if let &Opcode::Bnot = v632 {
                                                                                        if v104.1 == v633 {
                                                                                            if v2.0 == v264.0 {
                                                                                                let v638 = constructor_bnot(ctx, v2.0, v104.0);
                                                                                                let v639 = constructor_bor(ctx, v2.0, v104.1, v638);
                                                                                                // Rule at src/opts/bitops.isle line 688.
                                                                                                returns.extend(Some(v639));
                                                                                                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 v279 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v140.0, &mut v279);
                                                                            let mut v279 = v279.into_context_iter();
                                                                            while let Some(v280) = v279.next(ctx) {
                                                                                if let &InstructionData::Unary {
                                                                                    opcode: ref v635,
                                                                                    arg: v636,
                                                                                } = &v280.1 {
                                                                                    if let &Opcode::Bnot = v635 {
                                                                                        if v104.1 == v636 {
                                                                                            if v2.0 == v280.0 {
                                                                                                let v638 = constructor_bnot(ctx, v2.0, v104.0);
                                                                                                let v639 = constructor_bor(ctx, v2.0, v104.1, v638);
                                                                                                // Rule at src/opts/bitops.isle line 684.
                                                                                                returns.extend(Some(v639));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        if v104.1 == v140.0 {
                                                                            let mut v263 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v140.1, &mut v263);
                                                                            let mut v263 = v263.into_context_iter();
                                                                            while let Some(v264) = v263.next(ctx) {
                                                                                if let &InstructionData::Unary {
                                                                                    opcode: ref v632,
                                                                                    arg: v633,
                                                                                } = &v264.1 {
                                                                                    if let &Opcode::Bnot = v632 {
                                                                                        if v104.0 == v633 {
                                                                                            if v2.0 == v264.0 {
                                                                                                let v668 = constructor_bnot(ctx, v2.0, v104.1);
                                                                                                let v751 = constructor_bor(ctx, v2.0, v104.0, v668);
                                                                                                // Rule at src/opts/bitops.isle line 686.
                                                                                                returns.extend(Some(v751));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        if v104.1 == v140.1 {
                                                                            let mut v279 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v140.0, &mut v279);
                                                                            let mut v279 = v279.into_context_iter();
                                                                            while let Some(v280) = v279.next(ctx) {
                                                                                if let &InstructionData::Unary {
                                                                                    opcode: ref v635,
                                                                                    arg: v636,
                                                                                } = &v280.1 {
                                                                                    if let &Opcode::Bnot = v635 {
                                                                                        if v104.0 == v636 {
                                                                                            if v2.0 == v280.0 {
                                                                                                let v668 = constructor_bnot(ctx, v2.0, v104.1);
                                                                                                let v751 = constructor_bor(ctx, v2.0, v104.0, v668);
                                                                                                // Rule at src/opts/bitops.isle line 682.
                                                                                                returns.extend(Some(v751));
                                                                                                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 v749 = constructor_bnot(ctx, v2.0, v140.1);
                                                                        let v750 = constructor_bor(ctx, v2.0, v30, v749);
                                                                        // Rule at src/opts/bitops.isle line 325.
                                                                        returns.extend(Some(v750));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v30 == v140.1 {
                                                                        let v752 = constructor_bnot(ctx, v2.0, v140.0);
                                                                        let v753 = constructor_bor(ctx, v2.0, v30, v752);
                                                                        // Rule at src/opts/bitops.isle line 327.
                                                                        returns.extend(Some(v753));
                                                                        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 v638 = constructor_bnot(ctx, v2.0, v104.0);
                                                                                            let v892 = constructor_bor(ctx, v2.0, v119, v638);
                                                                                            // Rule at src/opts/bitops.isle line 687.
                                                                                            returns.extend(Some(v892));
                                                                                            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 v638 = constructor_bnot(ctx, v2.0, v104.0);
                                                                                            let v892 = constructor_bor(ctx, v2.0, v119, v638);
                                                                                            // Rule at src/opts/bitops.isle line 685.
                                                                                            returns.extend(Some(v892));
                                                                                            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 v668 = constructor_bnot(ctx, v2.0, v104.1);
                                                                                            let v890 = constructor_bor(ctx, v2.0, v112, v668);
                                                                                            // Rule at src/opts/bitops.isle line 681.
                                                                                            returns.extend(Some(v890));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                    if v112 == v140.1 {
                                                                                        if v104.1 == v140.0 {
                                                                                            let v668 = constructor_bnot(ctx, v2.0, v104.1);
                                                                                            let v890 = constructor_bor(ctx, v2.0, v112, v668);
                                                                                            // Rule at src/opts/bitops.isle line 683.
                                                                                            returns.extend(Some(v890));
                                                                                            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 v263 = C::inst_data_value_etor_returns::default();
                                                                                C::inst_data_value_etor(ctx, v140.1, &mut v263);
                                                                                let mut v263 = v263.into_context_iter();
                                                                                while let Some(v264) = v263.next(ctx) {
                                                                                    if let &InstructionData::UnaryImm {
                                                                                        opcode: ref v1129,
                                                                                        imm: v1130,
                                                                                    } = &v264.1 {
                                                                                        if let &Opcode::Iconst = v1129 {
                                                                                            let v1140 = constructor_bxor(ctx, v2.0, v104.0, v140.0);
                                                                                            let v1141 = constructor_bxor(ctx, v2.0, v104.1, v140.1);
                                                                                            let v1142 = constructor_bxor(ctx, v2.0, v1140, v1141);
                                                                                            // Rule at src/opts/cprop.isle line 329.
                                                                                            returns.extend(Some(v1142));
                                                                                            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 v760,
                                    args: ref v761,
                                    cond: ref v762,
                                } => {
                                    if let &Opcode::Icmp = v760 {
                                        match v762 {
                                            &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 v754,
                                                            args: ref v755,
                                                            cond: ref v756,
                                                        } = &v19.1 {
                                                            if let &Opcode::Icmp = v754 {
                                                                match v756 {
                                                                    &IntCC::SignedGreaterThan => {
                                                                        if v2.0 == v19.0 {
                                                                            let v757 = C::unpack_value_array_2(ctx, v755);
                                                                            let v763 = C::unpack_value_array_2(ctx, v761);
                                                                            if v757.0 == v763.1 {
                                                                                if v757.1 == v763.0 {
                                                                                    let v766 = constructor_ne(ctx, v2.0, v757.0, v757.1);
                                                                                    // Rule at src/opts/icmp.isle line 309.
                                                                                    returns.extend(Some(v766));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedLessThan => {
                                                                        if v2.0 == v19.0 {
                                                                            let v757 = C::unpack_value_array_2(ctx, v755);
                                                                            let v763 = C::unpack_value_array_2(ctx, v761);
                                                                            if v757.0 == v763.0 {
                                                                                if v757.1 == v763.1 {
                                                                                    let v766 = constructor_ne(ctx, v2.0, v757.0, v757.1);
                                                                                    // Rule at src/opts/icmp.isle line 311.
                                                                                    returns.extend(Some(v766));
                                                                                    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 v754,
                                                            args: ref v755,
                                                            cond: ref v756,
                                                        } = &v19.1 {
                                                            if let &Opcode::Icmp = v754 {
                                                                match v756 {
                                                                    &IntCC::SignedGreaterThan => {
                                                                        if v2.0 == v19.0 {
                                                                            let v757 = C::unpack_value_array_2(ctx, v755);
                                                                            let v763 = C::unpack_value_array_2(ctx, v761);
                                                                            if v757.0 == v763.0 {
                                                                                if v757.1 == v763.1 {
                                                                                    let v766 = constructor_ne(ctx, v2.0, v757.0, v757.1);
                                                                                    // Rule at src/opts/icmp.isle line 310.
                                                                                    returns.extend(Some(v766));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedLessThan => {
                                                                        if v2.0 == v19.0 {
                                                                            let v757 = C::unpack_value_array_2(ctx, v755);
                                                                            let v763 = C::unpack_value_array_2(ctx, v761);
                                                                            if v757.0 == v763.1 {
                                                                                if v757.1 == v763.0 {
                                                                                    let v766 = constructor_ne(ctx, v2.0, v757.0, v757.1);
                                                                                    // Rule at src/opts/icmp.isle line 312.
                                                                                    returns.extend(Some(v766));
                                                                                    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 v754,
                                                            args: ref v755,
                                                            cond: ref v756,
                                                        } = &v19.1 {
                                                            if let &Opcode::Icmp = v754 {
                                                                match v756 {
                                                                    &IntCC::UnsignedGreaterThan => {
                                                                        if v2.0 == v19.0 {
                                                                            let v757 = C::unpack_value_array_2(ctx, v755);
                                                                            let v763 = C::unpack_value_array_2(ctx, v761);
                                                                            if v757.0 == v763.1 {
                                                                                if v757.1 == v763.0 {
                                                                                    let v766 = constructor_ne(ctx, v2.0, v757.0, v757.1);
                                                                                    // Rule at src/opts/icmp.isle line 313.
                                                                                    returns.extend(Some(v766));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        if v2.0 == v19.0 {
                                                                            let v757 = C::unpack_value_array_2(ctx, v755);
                                                                            let v763 = C::unpack_value_array_2(ctx, v761);
                                                                            if v757.0 == v763.0 {
                                                                                if v757.1 == v763.1 {
                                                                                    let v766 = constructor_ne(ctx, v2.0, v757.0, v757.1);
                                                                                    // Rule at src/opts/icmp.isle line 315.
                                                                                    returns.extend(Some(v766));
                                                                                    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 v754,
                                                            args: ref v755,
                                                            cond: ref v756,
                                                        } = &v19.1 {
                                                            if let &Opcode::Icmp = v754 {
                                                                match v756 {
                                                                    &IntCC::UnsignedGreaterThan => {
                                                                        if v2.0 == v19.0 {
                                                                            let v757 = C::unpack_value_array_2(ctx, v755);
                                                                            let v763 = C::unpack_value_array_2(ctx, v761);
                                                                            if v757.0 == v763.0 {
                                                                                if v757.1 == v763.1 {
                                                                                    let v766 = constructor_ne(ctx, v2.0, v757.0, v757.1);
                                                                                    // Rule at src/opts/icmp.isle line 314.
                                                                                    returns.extend(Some(v766));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        if v2.0 == v19.0 {
                                                                            let v757 = C::unpack_value_array_2(ctx, v755);
                                                                            let v763 = C::unpack_value_array_2(ctx, v761);
                                                                            if v757.0 == v763.1 {
                                                                                if v757.1 == v763.0 {
                                                                                    let v766 = constructor_ne(ctx, v2.0, v757.0, v757.1);
                                                                                    // Rule at src/opts/icmp.isle line 316.
                                                                                    returns.extend(Some(v766));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v26,
                                    arg: v27,
                                } => {
                                    match v26 {
                                        &Opcode::Splat => {
                                            let v1990 = C::ty_vector_not_float(ctx, v2.0);
                                            if let Some(v1991) = v1990 {
                                                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 v1854 = C::lane_type(ctx, v2.0);
                                                                    let v1996 = constructor_bxor(ctx, v1854, v30, v27);
                                                                    let v1997 = constructor_splat(ctx, v2.0, v1996);
                                                                    // Rule at src/opts/vector.isle line 22.
                                                                    returns.extend(Some(v1997));
                                                                    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 {
                                                        match v102 {
                                                            &Opcode::Band => {
                                                                if v2.0 == v19.0 {
                                                                    let v104 = C::unpack_value_array_2(ctx, v103);
                                                                    if v27 == v104.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 {
                                                                                        let v630 = constructor_band(ctx, v2.0, v104.0, v119);
                                                                                        let v881 = constructor_bnot(ctx, v2.0, v630);
                                                                                        // Rule at src/opts/bitops.isle line 568.
                                                                                        returns.extend(Some(v881));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    if v27 == v104.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 v2.0 == v108.0 {
                                                                                        let v631 = constructor_band(ctx, v2.0, v104.1, v112);
                                                                                        let v884 = constructor_bnot(ctx, v2.0, v631);
                                                                                        // Rule at src/opts/bitops.isle line 570.
                                                                                        returns.extend(Some(v884));
                                                                                        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 v668 = constructor_bnot(ctx, v2.0, v104.1);
                                                                        let v751 = constructor_bor(ctx, v2.0, v104.0, v668);
                                                                        // Rule at src/opts/bitops.isle line 326.
                                                                        returns.extend(Some(v751));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v27 == v104.1 {
                                                                        let v638 = constructor_bnot(ctx, v2.0, v104.0);
                                                                        let v639 = constructor_bor(ctx, v2.0, v104.1, v638);
                                                                        // Rule at src/opts/bitops.isle line 328.
                                                                        returns.extend(Some(v639));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                    }
                                                }
                                            }
                                            let v348 = C::ty_int_vec128(ctx, v2.0);
                                            if let Some(v349) = v348 {
                                                if v11.0 == v349 {
                                                    if v7.0 == v27 {
                                                        let v350 = constructor_iconst_s(ctx, v349, -1_i64);
                                                        let v351 = C::subsume(ctx, v350);
                                                        // Rule at src/opts/bitops.isle line 22.
                                                        returns.extend(Some(v351));
                                                        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 v1347 = C::value_type(ctx, v30);
                                                        let v1378 = C::value_type(ctx, v27);
                                                        if v1347 == v1378 {
                                                            let v1383 = constructor_bxor(ctx, v1347, v30, v27);
                                                            let v1384 = constructor_uextend(ctx, v2.0, v1383);
                                                            // Rule at src/opts/extends.isle line 74.
                                                            returns.extend(Some(v1384));
                                                            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 v1060 = constructor_bxor(ctx, v2.0, v104.1, v7.1);
                                                                            let v1061 = constructor_bxor(ctx, v2.0, v104.0, v1060);
                                                                            // Rule at src/opts/cprop.isle line 222.
                                                                            returns.extend(Some(v1061));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        let v339 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v340) = v339 {
                                            if v11.0 == v340 {
                                                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 v972 = C::imm64_xor(ctx, v340, v23, v15);
                                                                let v973 = constructor_iconst(ctx, v340, v972);
                                                                let v974 = C::subsume(ctx, v973);
                                                                // Rule at src/opts/cprop.isle line 67.
                                                                returns.extend(Some(v974));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        let v1610 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 21.
                                        returns.extend(Some(v1610));
                                        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 v871 = constructor_bor(ctx, v2.0, v112, v104.1);
                                                                    // Rule at src/opts/bitops.isle line 574.
                                                                    returns.extend(Some(v871));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                let v868 = constructor_band(ctx, v2.0, v112, v104.1);
                                                                let v919 = constructor_bxor(ctx, v2.0, v7.1, v104.1);
                                                                let v920 = constructor_bxor(ctx, v2.0, v868, v919);
                                                                // Rule at src/opts/bitops.isle line 642.
                                                                returns.extend(Some(v920));
                                                                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 v872 = constructor_bor(ctx, v2.0, v119, v104.0);
                                                                    // Rule at src/opts/bitops.isle line 576.
                                                                    returns.extend(Some(v872));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                let v870 = constructor_band(ctx, v2.0, v119, v104.0);
                                                                let v924 = constructor_bxor(ctx, v2.0, v7.1, v104.0);
                                                                let v925 = constructor_bxor(ctx, v2.0, v870, v924);
                                                                // Rule at src/opts/bitops.isle line 644.
                                                                returns.extend(Some(v925));
                                                                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 v348 = C::ty_int_vec128(ctx, v2.0);
                                            if let Some(v349) = v348 {
                                                if v19.0 == v349 {
                                                    let v350 = constructor_iconst_s(ctx, v349, -1_i64);
                                                    let v351 = C::subsume(ctx, v350);
                                                    // Rule at src/opts/bitops.isle line 23.
                                                    returns.extend(Some(v351));
                                                    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 v1030 = constructor_bxor(ctx, v2.0, v7.1, v7.0);
                                            // Rule at src/opts/cprop.isle line 164.
                                            returns.extend(Some(v1030));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        let v1610 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 19.
                                        returns.extend(Some(v1610));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                _ => {}
                            }
                        }
                        if v7.0 == v7.1 {
                            let v344 = C::ty_int(ctx, v2.0);
                            if let Some(v345) = v344 {
                                let v346 = constructor_iconst_u(ctx, v345, 0x0_u64);
                                let v347 = C::subsume(ctx, v346);
                                // Rule at src/opts/bitops.isle line 17.
                                returns.extend(Some(v347));
                                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 v362 = constructor_bnot(ctx, v2.0, v7.0);
                                        // Rule at src/opts/bitops.isle line 72.
                                        returns.extend(Some(v362));
                                        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 v1850 = constructor_rotl(ctx, v2.0, v7.0, v140.0);
                                        // Rule at src/opts/shifts.isle line 142.
                                        returns.extend(Some(v1850));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v26,
                                    arg: v27,
                                } => {
                                    match v26 {
                                        &Opcode::Ireduce => {
                                            let v1378 = C::value_type(ctx, v27);
                                            let v1839 = C::fits_in_64(ctx, v1378);
                                            if let Some(v1840) = v1839 {
                                                let v1845 = constructor_rotl(ctx, v2.0, v7.0, v27);
                                                // Rule at src/opts/shifts.isle line 126.
                                                returns.extend(Some(v1845));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        &Opcode::Uextend => {
                                            let v1845 = constructor_rotl(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 127.
                                            returns.extend(Some(v1845));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Sextend => {
                                            let v1845 = constructor_rotl(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 128.
                                            returns.extend(Some(v1845));
                                            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 v1863 = constructor_iadd_uextend(ctx, v104.1, v7.1);
                                                                let v1864 = constructor_rotl(ctx, v2.0, v104.0, v1863);
                                                                // Rule at src/opts/shifts.isle line 239.
                                                                returns.extend(Some(v1864));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                        &Opcode::Rotr => {
                                                            if v2.0 == v19.0 {
                                                                let v104 = C::unpack_value_array_2(ctx, v103);
                                                                let v1866 = constructor_isub_uextend(ctx, v104.1, v7.1);
                                                                let v1868 = constructor_rotr(ctx, v2.0, v104.0, v1866);
                                                                // Rule at src/opts/shifts.isle line 246.
                                                                returns.extend(Some(v1868));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                &InstructionData::UnaryImm {
                                                    opcode: ref v22,
                                                    imm: v23,
                                                } => {
                                                    if let &Opcode::Iconst = v22 {
                                                        let v339 = C::fits_in_64(ctx, v2.0);
                                                        if let Some(v340) = v339 {
                                                            if v19.0 == v340 {
                                                                let v990 = C::imm64_rotl(ctx, v340, v23, v15);
                                                                let v991 = constructor_iconst(ctx, v340, v990);
                                                                let v992 = C::subsume(ctx, v991);
                                                                // Rule at src/opts/cprop.isle line 98.
                                                                returns.extend(Some(v992));
                                                                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 v363 = constructor_ty_shift_mask(ctx, v2.0);
                                        let v1852 = C::u64_and(ctx, v16, v363);
                                        let v1902 = C::u64_eq(ctx, v16, v1852);
                                        if v1902 == false {
                                            let v1903 = constructor_iconst_u(ctx, v11.0, v1852);
                                            let v1908 = constructor_rotl(ctx, v2.0, v7.0, v1903);
                                            // Rule at src/opts/shifts.isle line 308.
                                            returns.extend(Some(v1908));
                                            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 v1869 = C::value_type(ctx, v104.1);
                                                let v1870 = C::value_type(ctx, v7.1);
                                                if v1869 == v1870 {
                                                    let v1863 = constructor_iadd_uextend(ctx, v104.1, v7.1);
                                                    let v1864 = constructor_rotl(ctx, v2.0, v104.0, v1863);
                                                    // Rule at src/opts/shifts.isle line 260.
                                                    returns.extend(Some(v1864));
                                                    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 v1863 = constructor_iadd_uextend(ctx, v104.1, v7.1);
                                                            let v1864 = constructor_rotl(ctx, v2.0, v104.0, v1863);
                                                            // Rule at src/opts/shifts.isle line 238.
                                                            returns.extend(Some(v1864));
                                                            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 v1862 = C::subsume(ctx, v104.0);
                                                    // Rule at src/opts/shifts.isle line 203.
                                                    returns.extend(Some(v1862));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let v1869 = C::value_type(ctx, v104.1);
                                                let v1870 = C::value_type(ctx, v7.1);
                                                if v1869 == v1870 {
                                                    let v1866 = constructor_isub_uextend(ctx, v104.1, v7.1);
                                                    let v1868 = constructor_rotr(ctx, v2.0, v104.0, v1866);
                                                    // Rule at src/opts/shifts.isle line 265.
                                                    returns.extend(Some(v1868));
                                                    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 v1866 = constructor_isub_uextend(ctx, v104.1, v7.1);
                                                            let v1868 = constructor_rotr(ctx, v2.0, v104.0, v1866);
                                                            // Rule at src/opts/shifts.isle line 245.
                                                            returns.extend(Some(v1868));
                                                            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 v1854 = C::lane_type(ctx, v2.0);
                                            let v2024 = constructor_rotl(ctx, v1854, v30, v7.1);
                                            let v2025 = constructor_splat(ctx, v2.0, v2024);
                                            // Rule at src/opts/vector.isle line 68.
                                            returns.extend(Some(v2025));
                                            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 v1849 = constructor_rotr(ctx, v2.0, v7.0, v140.0);
                                        // Rule at src/opts/shifts.isle line 141.
                                        returns.extend(Some(v1849));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                &InstructionData::Ternary {
                                    opcode: ref v1871,
                                    args: ref v1872,
                                } => {
                                    if let &Opcode::Select = v1871 {
                                        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 v1873 = C::unpack_value_array_3(ctx, v1872);
                                                            let mut v1877 = C::inst_data_value_etor_returns::default();
                                                            C::inst_data_value_etor(ctx, v1873.1, &mut v1877);
                                                            let mut v1877 = v1877.into_context_iter();
                                                            while let Some(v1878) = v1877.next(ctx) {
                                                                if let &InstructionData::UnaryImm {
                                                                    opcode: ref v1881,
                                                                    imm: v1882,
                                                                } = &v1878.1 {
                                                                    if let &Opcode::Iconst = v1881 {
                                                                        if v2.0 == v1878.0 {
                                                                            let mut v1883 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v1873.2, &mut v1883);
                                                                            let mut v1883 = v1883.into_context_iter();
                                                                            while let Some(v1884) = v1883.next(ctx) {
                                                                                if let &InstructionData::UnaryImm {
                                                                                    opcode: ref v1887,
                                                                                    imm: v1888,
                                                                                } = &v1884.1 {
                                                                                    if let &Opcode::Iconst = v1887 {
                                                                                        if v2.0 == v1884.0 {
                                                                                            let v1889 = C::imm64_rotr(ctx, v2.0, v23, v1882);
                                                                                            let v1890 = constructor_iconst(ctx, v2.0, v1889);
                                                                                            let v1891 = C::imm64_rotr(ctx, v2.0, v23, v1888);
                                                                                            let v1892 = constructor_iconst(ctx, v2.0, v1891);
                                                                                            let v1893 = constructor_select(ctx, v2.0, v1873.0, v1890, v1892);
                                                                                            // Rule at src/opts/shifts.isle line 269.
                                                                                            returns.extend(Some(v1893));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v26,
                                    arg: v27,
                                } => {
                                    match v26 {
                                        &Opcode::Ireduce => {
                                            let v1378 = C::value_type(ctx, v27);
                                            let v1839 = C::fits_in_64(ctx, v1378);
                                            if let Some(v1840) = v1839 {
                                                let v1844 = constructor_rotr(ctx, v2.0, v7.0, v27);
                                                // Rule at src/opts/shifts.isle line 123.
                                                returns.extend(Some(v1844));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        &Opcode::Uextend => {
                                            let v1844 = constructor_rotr(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 124.
                                            returns.extend(Some(v1844));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Sextend => {
                                            let v1844 = constructor_rotr(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 125.
                                            returns.extend(Some(v1844));
                                            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 v1866 = constructor_isub_uextend(ctx, v104.1, v7.1);
                                                                let v1867 = constructor_rotl(ctx, v2.0, v104.0, v1866);
                                                                // Rule at src/opts/shifts.isle line 244.
                                                                returns.extend(Some(v1867));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                        &Opcode::Rotr => {
                                                            if v2.0 == v19.0 {
                                                                let v104 = C::unpack_value_array_2(ctx, v103);
                                                                let v1863 = constructor_iadd_uextend(ctx, v104.1, v7.1);
                                                                let v1865 = constructor_rotr(ctx, v2.0, v104.0, v1863);
                                                                // Rule at src/opts/shifts.isle line 241.
                                                                returns.extend(Some(v1865));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                &InstructionData::UnaryImm {
                                                    opcode: ref v22,
                                                    imm: v23,
                                                } => {
                                                    if let &Opcode::Iconst = v22 {
                                                        let v339 = C::fits_in_64(ctx, v2.0);
                                                        if let Some(v340) = v339 {
                                                            if v19.0 == v340 {
                                                                let v987 = C::imm64_rotr(ctx, v340, v23, v15);
                                                                let v988 = constructor_iconst(ctx, v340, v987);
                                                                let v989 = C::subsume(ctx, v988);
                                                                // Rule at src/opts/cprop.isle line 93.
                                                                returns.extend(Some(v989));
                                                                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 v363 = constructor_ty_shift_mask(ctx, v2.0);
                                        let v1852 = C::u64_and(ctx, v16, v363);
                                        let v1902 = C::u64_eq(ctx, v16, v1852);
                                        if v1902 == false {
                                            let v1903 = constructor_iconst_u(ctx, v11.0, v1852);
                                            let v1907 = constructor_rotr(ctx, v2.0, v7.0, v1903);
                                            // Rule at src/opts/shifts.isle line 305.
                                            returns.extend(Some(v1907));
                                            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 v1862 = C::subsume(ctx, v104.0);
                                                    // Rule at src/opts/shifts.isle line 204.
                                                    returns.extend(Some(v1862));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let v1869 = C::value_type(ctx, v104.1);
                                                let v1870 = C::value_type(ctx, v7.1);
                                                if v1869 == v1870 {
                                                    let v1866 = constructor_isub_uextend(ctx, v104.1, v7.1);
                                                    let v1867 = constructor_rotl(ctx, v2.0, v104.0, v1866);
                                                    // Rule at src/opts/shifts.isle line 263.
                                                    returns.extend(Some(v1867));
                                                    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 v1866 = constructor_isub_uextend(ctx, v104.1, v7.1);
                                                            let v1867 = constructor_rotl(ctx, v2.0, v104.0, v1866);
                                                            // Rule at src/opts/shifts.isle line 243.
                                                            returns.extend(Some(v1867));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Rotr => {
                                            if v2.0 == v19.0 {
                                                let v104 = C::unpack_value_array_2(ctx, v103);
                                                let v1869 = C::value_type(ctx, v104.1);
                                                let v1870 = C::value_type(ctx, v7.1);
                                                if v1869 == v1870 {
                                                    let v1863 = constructor_iadd_uextend(ctx, v104.1, v7.1);
                                                    let v1865 = constructor_rotr(ctx, v2.0, v104.0, v1863);
                                                    // Rule at src/opts/shifts.isle line 258.
                                                    returns.extend(Some(v1865));
                                                    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 v1863 = constructor_iadd_uextend(ctx, v104.1, v7.1);
                                                            let v1865 = constructor_rotr(ctx, v2.0, v104.0, v1863);
                                                            // Rule at src/opts/shifts.isle line 240.
                                                            returns.extend(Some(v1865));
                                                            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 v1854 = C::lane_type(ctx, v2.0);
                                            let v2026 = constructor_rotr(ctx, v1854, v30, v7.1);
                                            let v2027 = constructor_splat(ctx, v2.0, v2026);
                                            // Rule at src/opts/vector.isle line 71.
                                            returns.extend(Some(v2027));
                                            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 v1846 = constructor_ishl(ctx, v2.0, v7.0, v140.0);
                                        // Rule at src/opts/shifts.isle line 138.
                                        returns.extend(Some(v1846));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v26,
                                    arg: v27,
                                } => {
                                    match v26 {
                                        &Opcode::Ireduce => {
                                            let v1378 = C::value_type(ctx, v27);
                                            let v1839 = C::fits_in_64(ctx, v1378);
                                            if let Some(v1840) = v1839 {
                                                let v1841 = constructor_ishl(ctx, v2.0, v7.0, v27);
                                                // Rule at src/opts/shifts.isle line 114.
                                                returns.extend(Some(v1841));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        &Opcode::Uextend => {
                                            let v1841 = constructor_ishl(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 115.
                                            returns.extend(Some(v1841));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Sextend => {
                                            let v1841 = constructor_ishl(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 116.
                                            returns.extend(Some(v1841));
                                            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 v356 = C::u64_from_imm64(ctx, v133);
                                                                            let v363 = constructor_ty_shift_mask(ctx, v2.0);
                                                                            let v1851 = C::u64_and(ctx, v356, v363);
                                                                            let v16 = C::u64_from_imm64(ctx, v15);
                                                                            let v1852 = C::u64_and(ctx, v16, v363);
                                                                            let v1853 = C::u64_wrapping_add(ctx, v1851, v1852);
                                                                            let v1854 = C::lane_type(ctx, v2.0);
                                                                            let v1855 = C::ty_bits_u64(ctx, v1854);
                                                                            let v1856 = C::u64_lt(ctx, v1853, v1855);
                                                                            if v1856 == true {
                                                                                let v1857 = constructor_iconst_u(ctx, v115.0, v1853);
                                                                                let v1858 = constructor_ishl(ctx, v2.0, v104.0, v1857);
                                                                                // Rule at src/opts/shifts.isle line 151.
                                                                                returns.extend(Some(v1858));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                            let v1820 = C::ty_bits_u64(ctx, v2.0);
                                                                            let v1861 = C::u64_lt_eq(ctx, v1820, v1853);
                                                                            if v1861 == 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 v1042,
                                                                        imm: v1043,
                                                                    } = &v108.1 {
                                                                        if let &Opcode::Iconst = v1042 {
                                                                            let v1123 = constructor_ishl(ctx, v2.0, v104.0, v7.1);
                                                                            let v1124 = constructor_ishl(ctx, v2.0, v1123, v104.1);
                                                                            // Rule at src/opts/cprop.isle line 300.
                                                                            returns.extend(Some(v1124));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &Opcode::Ushr => {
                                                            let v339 = C::fits_in_64(ctx, v2.0);
                                                            if let Some(v340) = v339 {
                                                                if v19.0 == v340 {
                                                                    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 v1811 = C::imm64(ctx, 0xffffffffffffffff_u64);
                                                                                    let v1812 = C::imm64_shl(ctx, v340, v1811, v133);
                                                                                    let v1813 = constructor_iconst(ctx, v340, v1812);
                                                                                    let v1814 = constructor_band(ctx, v340, v104.0, v1813);
                                                                                    // Rule at src/opts/shifts.isle line 26.
                                                                                    returns.extend(Some(v1814));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &Opcode::Sshr => {
                                                            let v339 = C::fits_in_64(ctx, v2.0);
                                                            if let Some(v340) = v339 {
                                                                if v19.0 == v340 {
                                                                    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 v1811 = C::imm64(ctx, 0xffffffffffffffff_u64);
                                                                                    let v1812 = C::imm64_shl(ctx, v340, v1811, v133);
                                                                                    let v1813 = constructor_iconst(ctx, v340, v1812);
                                                                                    let v1814 = constructor_band(ctx, v340, v104.0, v1813);
                                                                                    // Rule at src/opts/shifts.isle line 31.
                                                                                    returns.extend(Some(v1814));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                &InstructionData::UnaryImm {
                                                    opcode: ref v22,
                                                    imm: v23,
                                                } => {
                                                    if let &Opcode::Iconst = v22 {
                                                        let v339 = C::fits_in_64(ctx, v2.0);
                                                        if let Some(v340) = v339 {
                                                            if v19.0 == v340 {
                                                                let v978 = C::imm64_shl(ctx, v340, v23, v15);
                                                                let v979 = constructor_iconst(ctx, v340, v978);
                                                                let v980 = C::subsume(ctx, v979);
                                                                // Rule at src/opts/cprop.isle line 78.
                                                                returns.extend(Some(v980));
                                                                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 v363 = constructor_ty_shift_mask(ctx, v2.0);
                                        let v1852 = C::u64_and(ctx, v16, v363);
                                        let v1902 = C::u64_eq(ctx, v16, v1852);
                                        if v1902 == false {
                                            let v1903 = constructor_iconst_u(ctx, v11.0, v1852);
                                            let v1904 = constructor_ishl(ctx, v2.0, v7.0, v1903);
                                            // Rule at src/opts/shifts.isle line 296.
                                            returns.extend(Some(v1904));
                                            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 v1854 = C::lane_type(ctx, v2.0);
                                        let v2028 = constructor_ishl(ctx, v1854, v30, v7.1);
                                        let v2029 = constructor_splat(ctx, v2.0, v2028);
                                        // Rule at src/opts/vector.isle line 74.
                                        returns.extend(Some(v2029));
                                        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 v1847 = constructor_ushr(ctx, v2.0, v7.0, v140.0);
                                        // Rule at src/opts/shifts.isle line 139.
                                        returns.extend(Some(v1847));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v26,
                                    arg: v27,
                                } => {
                                    match v26 {
                                        &Opcode::Ireduce => {
                                            let v1378 = C::value_type(ctx, v27);
                                            let v1839 = C::fits_in_64(ctx, v1378);
                                            if let Some(v1840) = v1839 {
                                                let v1842 = constructor_ushr(ctx, v2.0, v7.0, v27);
                                                // Rule at src/opts/shifts.isle line 117.
                                                returns.extend(Some(v1842));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        &Opcode::Uextend => {
                                            let v1842 = constructor_ushr(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 118.
                                            returns.extend(Some(v1842));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Sextend => {
                                            let v1842 = constructor_ushr(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 119.
                                            returns.extend(Some(v1842));
                                            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 v339 = C::fits_in_64(ctx, v2.0);
                                                                            if let Some(v340) = v339 {
                                                                                let v1455 = C::ty_int(ctx, v340);
                                                                                if let Some(v1456) = v1455 {
                                                                                    if v19.0 == v1456 {
                                                                                        let v1815 = C::ty_mask(ctx, v1456);
                                                                                        let v1816 = C::imm64(ctx, v1815);
                                                                                        let v1817 = C::imm64_ushr(ctx, v1456, v1816, v133);
                                                                                        let v1818 = constructor_iconst(ctx, v1456, v1817);
                                                                                        let v1819 = constructor_band(ctx, v1456, v104.0, v1818);
                                                                                        // Rule at src/opts/shifts.isle line 40.
                                                                                        returns.extend(Some(v1819));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                            let v344 = C::ty_int(ctx, v2.0);
                                                                            if let Some(v345) = v344 {
                                                                                let v356 = C::u64_from_imm64(ctx, v133);
                                                                                let v1826 = C::u64_matches_non_zero(ctx, v356);
                                                                                if let Some(v1827) = v1826 {
                                                                                    if v1827 == true {
                                                                                        let v1828 = C::ty_bits(ctx, v345);
                                                                                        let v1829 = C::u8_into_u64(ctx, v1828);
                                                                                        let v1830 = C::u64_wrapping_sub(ctx, v1829, v356);
                                                                                        let v1831 = constructor_shift_amt_to_type(ctx, v1830);
                                                                                        if let Some(v1832) = v1831 {
                                                                                            if v19.0 == v345 {
                                                                                                let v1833 = constructor_ireduce(ctx, v1832, v104.0);
                                                                                                let v1835 = constructor_uextend(ctx, v345, v1833);
                                                                                                // Rule at src/opts/shifts.isle line 87.
                                                                                                returns.extend(Some(v1835));
                                                                                                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 v356 = C::u64_from_imm64(ctx, v133);
                                                                            let v363 = constructor_ty_shift_mask(ctx, v2.0);
                                                                            let v1851 = C::u64_and(ctx, v356, v363);
                                                                            let v16 = C::u64_from_imm64(ctx, v15);
                                                                            let v1852 = C::u64_and(ctx, v16, v363);
                                                                            let v1853 = C::u64_wrapping_add(ctx, v1851, v1852);
                                                                            let v1854 = C::lane_type(ctx, v2.0);
                                                                            let v1855 = C::ty_bits_u64(ctx, v1854);
                                                                            let v1856 = C::u64_lt(ctx, v1853, v1855);
                                                                            if v1856 == true {
                                                                                let v1857 = constructor_iconst_u(ctx, v115.0, v1853);
                                                                                let v1859 = constructor_ushr(ctx, v2.0, v104.0, v1857);
                                                                                // Rule at src/opts/shifts.isle line 160.
                                                                                returns.extend(Some(v1859));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                            let v1820 = C::ty_bits_u64(ctx, v2.0);
                                                                            let v1861 = C::u64_lt_eq(ctx, v1820, v1853);
                                                                            if v1861 == 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 v1042,
                                                                        imm: v1043,
                                                                    } = &v108.1 {
                                                                        if let &Opcode::Iconst = v1042 {
                                                                            let v1125 = constructor_ushr(ctx, v2.0, v104.0, v7.1);
                                                                            let v1126 = constructor_ushr(ctx, v2.0, v1125, v104.1);
                                                                            // Rule at src/opts/cprop.isle line 302.
                                                                            returns.extend(Some(v1126));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                &InstructionData::UnaryImm {
                                                    opcode: ref v22,
                                                    imm: v23,
                                                } => {
                                                    if let &Opcode::Iconst = v22 {
                                                        let v339 = C::fits_in_64(ctx, v2.0);
                                                        if let Some(v340) = v339 {
                                                            if v19.0 == v340 {
                                                                let v981 = C::imm64_ushr(ctx, v340, v23, v15);
                                                                let v982 = constructor_iconst(ctx, v340, v981);
                                                                let v983 = C::subsume(ctx, v982);
                                                                // Rule at src/opts/cprop.isle line 83.
                                                                returns.extend(Some(v983));
                                                                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 v363 = constructor_ty_shift_mask(ctx, v2.0);
                                        let v1852 = C::u64_and(ctx, v16, v363);
                                        let v1902 = C::u64_eq(ctx, v16, v1852);
                                        if v1902 == false {
                                            let v1903 = constructor_iconst_u(ctx, v11.0, v1852);
                                            let v1905 = constructor_ushr(ctx, v2.0, v7.0, v1903);
                                            // Rule at src/opts/shifts.isle line 299.
                                            returns.extend(Some(v1905));
                                            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 v289,
                                                    args: ref v290,
                                                } = &v108.1 {
                                                    if let &Opcode::Ishl = v289 {
                                                        if v2.0 == v108.0 {
                                                            let v291 = C::unpack_value_array_2(ctx, v290);
                                                            if v7.1 == v291.1 {
                                                                let v1912 = constructor_ushr(ctx, v2.0, v104.1, v291.1);
                                                                let v1913 = constructor_band(ctx, v2.0, v291.0, v1912);
                                                                // Rule at src/opts/shifts.isle line 316.
                                                                returns.extend(Some(v1913));
                                                                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 v1854 = C::lane_type(ctx, v2.0);
                                            let v2030 = constructor_ushr(ctx, v1854, v30, v7.1);
                                            let v2031 = constructor_splat(ctx, v2.0, v2030);
                                            // Rule at src/opts/vector.isle line 77.
                                            returns.extend(Some(v2031));
                                            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 v1848 = constructor_sshr(ctx, v2.0, v7.0, v140.0);
                                        // Rule at src/opts/shifts.isle line 140.
                                        returns.extend(Some(v1848));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v26,
                                    arg: v27,
                                } => {
                                    match v26 {
                                        &Opcode::Ireduce => {
                                            let v1378 = C::value_type(ctx, v27);
                                            let v1839 = C::fits_in_64(ctx, v1378);
                                            if let Some(v1840) = v1839 {
                                                let v1843 = constructor_sshr(ctx, v2.0, v7.0, v27);
                                                // Rule at src/opts/shifts.isle line 120.
                                                returns.extend(Some(v1843));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        &Opcode::Uextend => {
                                            let v1843 = constructor_sshr(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 121.
                                            returns.extend(Some(v1843));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Sextend => {
                                            let v1843 = constructor_sshr(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 122.
                                            returns.extend(Some(v1843));
                                            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 v363 = constructor_ty_shift_mask(ctx, v2.0);
                                                            let v364 = C::u64_eq(ctx, v16, v363);
                                                            if v364 == 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 v366 = constructor_bmask(ctx, v2.0, v112);
                                                                                            // Rule at src/opts/bitops.isle line 83.
                                                                                            returns.extend(Some(v366));
                                                                                            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 v365 = constructor_bmask(ctx, v2.0, v104.0);
                                                                                            // Rule at src/opts/bitops.isle line 79.
                                                                                            returns.extend(Some(v365));
                                                                                            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 v356 = C::u64_from_imm64(ctx, v133);
                                                                            if v16 == v356 {
                                                                                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 v1820 = C::ty_bits_u64(ctx, v2.0);
                                                                                                    let v113 = C::value_type(ctx, v112);
                                                                                                    let v124 = C::ty_bits_u64(ctx, v113);
                                                                                                    let v1821 = C::u64_wrapping_sub(ctx, v1820, v124);
                                                                                                    let v1822 = C::u64_eq(ctx, v356, v1821);
                                                                                                    if v1822 == true {
                                                                                                        let v1823 = constructor_sextend(ctx, v2.0, v112);
                                                                                                        // Rule at src/opts/shifts.isle line 49.
                                                                                                        returns.extend(Some(v1823));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                    let v1824 = C::u64_lt(ctx, v356, v1821);
                                                                                                    if v1824 == true {
                                                                                                        // Rule at src/opts/shifts.isle line 60.
                                                                                                        returns.extend(Some(v104.0));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                            &Opcode::Sextend => {
                                                                                                let v1820 = C::ty_bits_u64(ctx, v2.0);
                                                                                                let v113 = C::value_type(ctx, v112);
                                                                                                let v124 = C::ty_bits_u64(ctx, v113);
                                                                                                let v1821 = C::u64_wrapping_sub(ctx, v1820, v124);
                                                                                                let v1825 = C::u64_lt_eq(ctx, v356, v1821);
                                                                                                if v1825 == 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 v344 = C::ty_int(ctx, v2.0);
                                                                            if let Some(v345) = v344 {
                                                                                if v19.0 == v345 {
                                                                                    let v356 = C::u64_from_imm64(ctx, v133);
                                                                                    let v1826 = C::u64_matches_non_zero(ctx, v356);
                                                                                    if let Some(v1827) = v1826 {
                                                                                        if v1827 == true {
                                                                                            let v1828 = C::ty_bits(ctx, v345);
                                                                                            let v1829 = C::u8_into_u64(ctx, v1828);
                                                                                            let v1830 = C::u64_wrapping_sub(ctx, v1829, v356);
                                                                                            let v1831 = constructor_shift_amt_to_type(ctx, v1830);
                                                                                            if let Some(v1832) = v1831 {
                                                                                                let v1833 = constructor_ireduce(ctx, v1832, v104.0);
                                                                                                let v1834 = constructor_sextend(ctx, v345, v1833);
                                                                                                // Rule at src/opts/shifts.isle line 83.
                                                                                                returns.extend(Some(v1834));
                                                                                                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 v1042,
                                                                        imm: v1043,
                                                                    } = &v108.1 {
                                                                        if let &Opcode::Iconst = v1042 {
                                                                            let v1127 = constructor_sshr(ctx, v2.0, v104.0, v7.1);
                                                                            let v1128 = constructor_sshr(ctx, v2.0, v1127, v104.1);
                                                                            // Rule at src/opts/cprop.isle line 304.
                                                                            returns.extend(Some(v1128));
                                                                            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 v356 = C::u64_from_imm64(ctx, v133);
                                                                            let v363 = constructor_ty_shift_mask(ctx, v2.0);
                                                                            let v1851 = C::u64_and(ctx, v356, v363);
                                                                            let v16 = C::u64_from_imm64(ctx, v15);
                                                                            let v1852 = C::u64_and(ctx, v16, v363);
                                                                            let v1853 = C::u64_wrapping_add(ctx, v1851, v1852);
                                                                            let v1854 = C::lane_type(ctx, v2.0);
                                                                            let v1855 = C::ty_bits_u64(ctx, v1854);
                                                                            let v1856 = C::u64_lt(ctx, v1853, v1855);
                                                                            if v1856 == true {
                                                                                let v1857 = constructor_iconst_u(ctx, v115.0, v1853);
                                                                                let v1860 = constructor_sshr(ctx, v2.0, v104.0, v1857);
                                                                                // Rule at src/opts/shifts.isle line 169.
                                                                                returns.extend(Some(v1860));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                &InstructionData::UnaryImm {
                                                    opcode: ref v22,
                                                    imm: v23,
                                                } => {
                                                    if let &Opcode::Iconst = v22 {
                                                        let v339 = C::fits_in_64(ctx, v2.0);
                                                        if let Some(v340) = v339 {
                                                            if v19.0 == v340 {
                                                                let v984 = C::imm64_sshr(ctx, v340, v23, v15);
                                                                let v985 = constructor_iconst(ctx, v340, v984);
                                                                let v986 = C::subsume(ctx, v985);
                                                                // Rule at src/opts/cprop.isle line 88.
                                                                returns.extend(Some(v986));
                                                                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 v363 = constructor_ty_shift_mask(ctx, v2.0);
                                        let v1852 = C::u64_and(ctx, v16, v363);
                                        let v1902 = C::u64_eq(ctx, v16, v1852);
                                        if v1902 == false {
                                            let v1903 = constructor_iconst_u(ctx, v11.0, v1852);
                                            let v1906 = constructor_sshr(ctx, v2.0, v7.0, v1903);
                                            // Rule at src/opts/shifts.isle line 302.
                                            returns.extend(Some(v1906));
                                            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 v1854 = C::lane_type(ctx, v2.0);
                                        let v2032 = constructor_sshr(ctx, v1854, v30, v7.1);
                                        let v2033 = constructor_splat(ctx, v2.0, v2032);
                                        // Rule at src/opts/vector.isle line 80.
                                        returns.extend(Some(v2033));
                                        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 v1167,
                                            imm: v1168,
                                        } = &v11.1 {
                                            if let &Opcode::F32const = v1167 {
                                                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 v1165,
                                                            imm: v1166,
                                                        } = &v19.1 {
                                                            if let &Opcode::F32const = v1165 {
                                                                let v1169 = C::f32_add(ctx, v1166, v1168);
                                                                if let Some(v1170) = v1169 {
                                                                    let v1171 = constructor_f32const(ctx, F32, v1170);
                                                                    let v1172 = C::subsume(ctx, v1171);
                                                                    // Rule at src/opts/cprop.isle line 378.
                                                                    returns.extend(Some(v1172));
                                                                    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 v1175,
                                            imm: v1176,
                                        } = &v11.1 {
                                            if let &Opcode::F64const = v1175 {
                                                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 v1173,
                                                            imm: v1174,
                                                        } = &v19.1 {
                                                            if let &Opcode::F64const = v1173 {
                                                                let v1177 = C::f64_add(ctx, v1174, v1176);
                                                                if let Some(v1178) = v1177 {
                                                                    let v1179 = constructor_f64const(ctx, F64, v1178);
                                                                    let v1180 = C::subsume(ctx, v1179);
                                                                    // Rule at src/opts/cprop.isle line 381.
                                                                    returns.extend(Some(v1180));
                                                                    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 v1167,
                                            imm: v1168,
                                        } = &v11.1 {
                                            if let &Opcode::F32const = v1167 {
                                                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 v1165,
                                                            imm: v1166,
                                                        } = &v19.1 {
                                                            if let &Opcode::F32const = v1165 {
                                                                let v1181 = C::f32_sub(ctx, v1166, v1168);
                                                                if let Some(v1182) = v1181 {
                                                                    let v1183 = constructor_f32const(ctx, F32, v1182);
                                                                    let v1184 = C::subsume(ctx, v1183);
                                                                    // Rule at src/opts/cprop.isle line 385.
                                                                    returns.extend(Some(v1184));
                                                                    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 v1175,
                                            imm: v1176,
                                        } = &v11.1 {
                                            if let &Opcode::F64const = v1175 {
                                                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 v1173,
                                                            imm: v1174,
                                                        } = &v19.1 {
                                                            if let &Opcode::F64const = v1173 {
                                                                let v1185 = C::f64_sub(ctx, v1174, v1176);
                                                                if let Some(v1186) = v1185 {
                                                                    let v1187 = constructor_f64const(ctx, F64, v1186);
                                                                    let v1188 = C::subsume(ctx, v1187);
                                                                    // Rule at src/opts/cprop.isle line 388.
                                                                    returns.extend(Some(v1188));
                                                                    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 v1167,
                                    imm: v1168,
                                } => {
                                    if let &Opcode::F32const = v1167 {
                                        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 v1165,
                                                            imm: v1166,
                                                        } = &v19.1 {
                                                            if let &Opcode::F32const = v1165 {
                                                                let v1189 = C::f32_mul(ctx, v1166, v1168);
                                                                if let Some(v1190) = v1189 {
                                                                    let v1191 = constructor_f32const(ctx, F32, v1190);
                                                                    let v1192 = C::subsume(ctx, v1191);
                                                                    // Rule at src/opts/cprop.isle line 392.
                                                                    returns.extend(Some(v1192));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryIeee64 {
                                    opcode: ref v1175,
                                    imm: v1176,
                                } => {
                                    if let &Opcode::F64const = v1175 {
                                        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 v1173,
                                                            imm: v1174,
                                                        } = &v19.1 {
                                                            if let &Opcode::F64const = v1173 {
                                                                let v1193 = C::f64_mul(ctx, v1174, v1176);
                                                                if let Some(v1194) = v1193 {
                                                                    let v1195 = constructor_f64const(ctx, F64, v1194);
                                                                    let v1196 = C::subsume(ctx, v1195);
                                                                    // Rule at src/opts/cprop.isle line 395.
                                                                    returns.extend(Some(v1196));
                                                                    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 v1167,
                                            imm: v1168,
                                        } = &v11.1 {
                                            if let &Opcode::F32const = v1167 {
                                                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 v1165,
                                                            imm: v1166,
                                                        } = &v19.1 {
                                                            if let &Opcode::F32const = v1165 {
                                                                let v1197 = C::f32_div(ctx, v1166, v1168);
                                                                if let Some(v1198) = v1197 {
                                                                    let v1199 = constructor_f32const(ctx, F32, v1198);
                                                                    let v1200 = C::subsume(ctx, v1199);
                                                                    // Rule at src/opts/cprop.isle line 399.
                                                                    returns.extend(Some(v1200));
                                                                    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 v1175,
                                            imm: v1176,
                                        } = &v11.1 {
                                            if let &Opcode::F64const = v1175 {
                                                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 v1173,
                                                            imm: v1174,
                                                        } = &v19.1 {
                                                            if let &Opcode::F64const = v1173 {
                                                                let v1201 = C::f64_div(ctx, v1174, v1176);
                                                                if let Some(v1202) = v1201 {
                                                                    let v1203 = constructor_f64const(ctx, F64, v1202);
                                                                    let v1204 = C::subsume(ctx, v1203);
                                                                    // Rule at src/opts/cprop.isle line 402.
                                                                    returns.extend(Some(v1204));
                                                                    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 v1247,
                                            imm: v1248,
                                        } = &v11.1 {
                                            if let &Opcode::F16const = v1247 {
                                                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 v1245,
                                                            imm: v1246,
                                                        } = &v19.1 {
                                                            if let &Opcode::F16const = v1245 {
                                                                let v1325 = C::f16_copysign(ctx, v1246, v1248);
                                                                let v1326 = constructor_f16const(ctx, F16, v1325);
                                                                let v1327 = C::subsume(ctx, v1326);
                                                                // Rule at src/opts/cprop.isle line 485.
                                                                returns.extend(Some(v1327));
                                                                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 v1167,
                                            imm: v1168,
                                        } = &v11.1 {
                                            if let &Opcode::F32const = v1167 {
                                                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 v1165,
                                                            imm: v1166,
                                                        } = &v19.1 {
                                                            if let &Opcode::F32const = v1165 {
                                                                let v1328 = C::f32_copysign(ctx, v1166, v1168);
                                                                let v1329 = constructor_f32const(ctx, F32, v1328);
                                                                let v1330 = C::subsume(ctx, v1329);
                                                                // Rule at src/opts/cprop.isle line 487.
                                                                returns.extend(Some(v1330));
                                                                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 v1175,
                                            imm: v1176,
                                        } = &v11.1 {
                                            if let &Opcode::F64const = v1175 {
                                                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 v1173,
                                                            imm: v1174,
                                                        } = &v19.1 {
                                                            if let &Opcode::F64const = v1173 {
                                                                let v1331 = C::f64_copysign(ctx, v1174, v1176);
                                                                let v1332 = constructor_f64const(ctx, F64, v1331);
                                                                let v1333 = C::subsume(ctx, v1332);
                                                                // Rule at src/opts/cprop.isle line 489.
                                                                returns.extend(Some(v1333));
                                                                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 v1266,
                                            constant_handle: v1267,
                                        } = &v11.1 {
                                            if let &Opcode::F128const = v1266 {
                                                let v1268 = C::ieee128_constant_extractor(ctx, v1267);
                                                if let Some(v1269) = v1268 {
                                                    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 v1262,
                                                                constant_handle: v1263,
                                                            } = &v19.1 {
                                                                if let &Opcode::F128const = v1262 {
                                                                    let v1264 = C::ieee128_constant_extractor(ctx, v1263);
                                                                    if let Some(v1265) = v1264 {
                                                                        let v1334 = C::f128_copysign(ctx, v1265, v1269);
                                                                        let v1335 = C::ieee128_constant(ctx, v1334);
                                                                        let v1336 = constructor_f128const(ctx, F128, v1335);
                                                                        let v1337 = C::subsume(ctx, v1336);
                                                                        // Rule at src/opts/cprop.isle line 491.
                                                                        returns.extend(Some(v1337));
                                                                        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 v1247,
                                            imm: v1248,
                                        } = &v11.1 {
                                            if let &Opcode::F16const = v1247 {
                                                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 v1245,
                                                            imm: v1246,
                                                        } = &v19.1 {
                                                            if let &Opcode::F16const = v1245 {
                                                                let v1249 = C::f16_min(ctx, v1246, v1248);
                                                                if let Some(v1250) = v1249 {
                                                                    let v1252 = constructor_f16const(ctx, F16, v1250);
                                                                    let v1253 = C::subsume(ctx, v1252);
                                                                    // Rule at src/opts/cprop.isle line 441.
                                                                    returns.extend(Some(v1253));
                                                                    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 v1167,
                                            imm: v1168,
                                        } = &v11.1 {
                                            if let &Opcode::F32const = v1167 {
                                                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 v1165,
                                                            imm: v1166,
                                                        } = &v19.1 {
                                                            if let &Opcode::F32const = v1165 {
                                                                let v1254 = C::f32_min(ctx, v1166, v1168);
                                                                if let Some(v1255) = v1254 {
                                                                    let v1256 = constructor_f32const(ctx, F32, v1255);
                                                                    let v1257 = C::subsume(ctx, v1256);
                                                                    // Rule at src/opts/cprop.isle line 444.
                                                                    returns.extend(Some(v1257));
                                                                    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 v1175,
                                            imm: v1176,
                                        } = &v11.1 {
                                            if let &Opcode::F64const = v1175 {
                                                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 v1173,
                                                            imm: v1174,
                                                        } = &v19.1 {
                                                            if let &Opcode::F64const = v1173 {
                                                                let v1258 = C::f64_min(ctx, v1174, v1176);
                                                                if let Some(v1259) = v1258 {
                                                                    let v1260 = constructor_f64const(ctx, F64, v1259);
                                                                    let v1261 = C::subsume(ctx, v1260);
                                                                    // Rule at src/opts/cprop.isle line 447.
                                                                    returns.extend(Some(v1261));
                                                                    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 v1266,
                                            constant_handle: v1267,
                                        } = &v11.1 {
                                            if let &Opcode::F128const = v1266 {
                                                let v1268 = C::ieee128_constant_extractor(ctx, v1267);
                                                if let Some(v1269) = v1268 {
                                                    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 v1262,
                                                                constant_handle: v1263,
                                                            } = &v19.1 {
                                                                if let &Opcode::F128const = v1262 {
                                                                    let v1264 = C::ieee128_constant_extractor(ctx, v1263);
                                                                    if let Some(v1265) = v1264 {
                                                                        let v1270 = C::f128_min(ctx, v1265, v1269);
                                                                        if let Some(v1271) = v1270 {
                                                                            let v1273 = C::ieee128_constant(ctx, v1271);
                                                                            let v1274 = constructor_f128const(ctx, F128, v1273);
                                                                            let v1275 = C::subsume(ctx, v1274);
                                                                            // Rule at src/opts/cprop.isle line 450.
                                                                            returns.extend(Some(v1275));
                                                                            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 v1247,
                                            imm: v1248,
                                        } = &v11.1 {
                                            if let &Opcode::F16const = v1247 {
                                                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 v1245,
                                                            imm: v1246,
                                                        } = &v19.1 {
                                                            if let &Opcode::F16const = v1245 {
                                                                let v1276 = C::f16_max(ctx, v1246, v1248);
                                                                if let Some(v1277) = v1276 {
                                                                    let v1278 = constructor_f16const(ctx, F16, v1277);
                                                                    let v1279 = C::subsume(ctx, v1278);
                                                                    // Rule at src/opts/cprop.isle line 454.
                                                                    returns.extend(Some(v1279));
                                                                    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 v1167,
                                            imm: v1168,
                                        } = &v11.1 {
                                            if let &Opcode::F32const = v1167 {
                                                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 v1165,
                                                            imm: v1166,
                                                        } = &v19.1 {
                                                            if let &Opcode::F32const = v1165 {
                                                                let v1280 = C::f32_max(ctx, v1166, v1168);
                                                                if let Some(v1281) = v1280 {
                                                                    let v1282 = constructor_f32const(ctx, F32, v1281);
                                                                    let v1283 = C::subsume(ctx, v1282);
                                                                    // Rule at src/opts/cprop.isle line 457.
                                                                    returns.extend(Some(v1283));
                                                                    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 v1175,
                                            imm: v1176,
                                        } = &v11.1 {
                                            if let &Opcode::F64const = v1175 {
                                                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 v1173,
                                                            imm: v1174,
                                                        } = &v19.1 {
                                                            if let &Opcode::F64const = v1173 {
                                                                let v1284 = C::f64_max(ctx, v1174, v1176);
                                                                if let Some(v1285) = v1284 {
                                                                    let v1286 = constructor_f64const(ctx, F64, v1285);
                                                                    let v1287 = C::subsume(ctx, v1286);
                                                                    // Rule at src/opts/cprop.isle line 460.
                                                                    returns.extend(Some(v1287));
                                                                    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 v1266,
                                            constant_handle: v1267,
                                        } = &v11.1 {
                                            if let &Opcode::F128const = v1266 {
                                                let v1268 = C::ieee128_constant_extractor(ctx, v1267);
                                                if let Some(v1269) = v1268 {
                                                    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 v1262,
                                                                constant_handle: v1263,
                                                            } = &v19.1 {
                                                                if let &Opcode::F128const = v1262 {
                                                                    let v1264 = C::ieee128_constant_extractor(ctx, v1263);
                                                                    if let Some(v1265) = v1264 {
                                                                        let v1288 = C::f128_max(ctx, v1265, v1269);
                                                                        if let Some(v1289) = v1288 {
                                                                            let v1290 = C::ieee128_constant(ctx, v1289);
                                                                            let v1291 = constructor_f128const(ctx, F128, v1290);
                                                                            let v1292 = C::subsume(ctx, v1291);
                                                                            // Rule at src/opts/cprop.isle line 463.
                                                                            returns.extend(Some(v1292));
                                                                            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 v263 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v140.1, &mut v263);
                                                let mut v263 = v263.into_context_iter();
                                                while let Some(v264) = v263.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v1129,
                                                        imm: v1130,
                                                    } = &v264.1 {
                                                        if let &Opcode::Iconst = v1129 {
                                                            let v1398 = C::u64_from_imm64(ctx, v1130);
                                                            if v1398 == 0x3f_u64 {
                                                                let v1399 = constructor_sextend(ctx, I128, v7.0);
                                                                // Rule at src/opts/extends.isle line 94.
                                                                returns.extend(Some(v1399));
                                                                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 v1397 = constructor_uextend(ctx, I128, v7.0);
                                                // Rule at src/opts/extends.isle line 93.
                                                returns.extend(Some(v1397));
                                                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 {
                                                                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 {
                                                                        if v171.1 == v205.1 {
                                                                            let v295 = constructor_cmp_true(ctx, v2.0);
                                                                            // Rule at src/opts/arithmetic.isle line 390.
                                                                            returns.extend(Some(v295));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            // Rule at src/opts/arithmetic.isle line 391.
                                                                            returns.extend(Some(v295));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v171.0 == v205.1 {
                                                                        if v171.1 == v205.0 {
                                                                            let v295 = constructor_cmp_true(ctx, v2.0);
                                                                            // Rule at src/opts/arithmetic.isle line 388.
                                                                            returns.extend(Some(v295));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            // Rule at src/opts/arithmetic.isle line 389.
                                                                            returns.extend(Some(v295));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                let v171 = C::unpack_value_array_2(ctx, v170);
                                                                let v205 = C::unpack_value_array_2(ctx, v204);
                                                                if v171.0 == v205.0 {
                                                                    let v735 = constructor_eq(ctx, v2.0, v205.1, v171.1);
                                                                    let v1405 = C::subsume(ctx, v735);
                                                                    // Rule at src/opts/icmp.isle line 26.
                                                                    returns.extend(Some(v1405));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v171.0 == v205.1 {
                                                                    let v731 = constructor_eq(ctx, v2.0, v205.0, v171.1);
                                                                    let v1403 = C::subsume(ctx, v731);
                                                                    // Rule at src/opts/icmp.isle line 22.
                                                                    returns.extend(Some(v1403));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v171.1 == v205.0 {
                                                                    let v733 = constructor_eq(ctx, v2.0, v205.1, v171.0);
                                                                    let v1404 = C::subsume(ctx, v733);
                                                                    // Rule at src/opts/icmp.isle line 24.
                                                                    returns.extend(Some(v1404));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v171.1 == v205.1 {
                                                                    let v729 = constructor_eq(ctx, v2.0, v205.0, v171.0);
                                                                    let v1402 = C::subsume(ctx, v729);
                                                                    // Rule at src/opts/icmp.isle line 20.
                                                                    returns.extend(Some(v1402));
                                                                    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 v1083 = constructor_isub(ctx, v166.0, v171.1, v205.1);
                                                                                        let v1084 = constructor_iadd(ctx, v159.0, v171.0, v1083);
                                                                                        let v1085 = constructor_eq(ctx, v2.0, v205.0, v1084);
                                                                                        // Rule at src/opts/cprop.isle line 256.
                                                                                        returns.extend(Some(v1085));
                                                                                        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 v1077 = constructor_isub(ctx, v159.0, v155.1, v205.1);
                                                                            let v1078 = constructor_eq(ctx, v2.0, v205.0, v1077);
                                                                            // Rule at src/opts/cprop.isle line 246.
                                                                            returns.extend(Some(v1078));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let v205 = C::unpack_value_array_2(ctx, v204);
                                                if v155.1 == v205.0 {
                                                    let v296 = constructor_iconst_u(ctx, v159.0, 0x0_u64);
                                                    let v300 = constructor_eq(ctx, v2.0, v205.1, v296);
                                                    // Rule at src/opts/arithmetic.isle line 403.
                                                    returns.extend(Some(v300));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v155.1 == v205.1 {
                                                    let v296 = constructor_iconst_u(ctx, v159.0, 0x0_u64);
                                                    let v302 = constructor_eq(ctx, v2.0, v205.0, v296);
                                                    // Rule at src/opts/arithmetic.isle line 402.
                                                    returns.extend(Some(v302));
                                                    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 v1970,
                                                            args: ref v1971,
                                                            cond: ref v1972,
                                                        } => {
                                                            if let &Opcode::Icmp = v1970 {
                                                                match v1972 {
                                                                    &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 v1964,
                                                                                    args: ref v1965,
                                                                                    cond: ref v1966,
                                                                                } = &v226.1 {
                                                                                    if let &Opcode::Icmp = v1964 {
                                                                                        if let &IntCC::SignedGreaterThan = v1966 {
                                                                                            if v209.0 == v226.0 {
                                                                                                let v1967 = C::unpack_value_array_2(ctx, v1965);
                                                                                                let v1973 = C::unpack_value_array_2(ctx, v1971);
                                                                                                if v1967.0 == v1973.0 {
                                                                                                    if v1967.1 == v1973.1 {
                                                                                                        let mut v1357 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                        C::inst_data_value_tupled_etor(ctx, v155.1, &mut v1357);
                                                                                                        let mut v1357 = v1357.into_context_iter();
                                                                                                        while let Some(v1358) = v1357.next(ctx) {
                                                                                                            let v1359 = C::iconst_sextend_etor(ctx, v1358);
                                                                                                            if let Some(v1360) = v1359 {
                                                                                                                match v1360.1 {
                                                                                                                    -1_i64 => {
                                                                                                                        let v1978 = constructor_slt(ctx, v226.0, v1967.0, v1967.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 178.
                                                                                                                        returns.extend(Some(v1978));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                    0_i64 => {
                                                                                                                        let v1976 = constructor_eq(ctx, v226.0, v1967.0, v1967.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 145.
                                                                                                                        returns.extend(Some(v1976));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                    1_i64 => {
                                                                                                                        let v1982 = constructor_sgt(ctx, v226.0, v1967.0, v1967.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 186.
                                                                                                                        returns.extend(Some(v1982));
                                                                                                                        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 v1964,
                                                                                    args: ref v1965,
                                                                                    cond: ref v1966,
                                                                                } = &v226.1 {
                                                                                    if let &Opcode::Icmp = v1964 {
                                                                                        if let &IntCC::UnsignedGreaterThan = v1966 {
                                                                                            if v209.0 == v226.0 {
                                                                                                let v1967 = C::unpack_value_array_2(ctx, v1965);
                                                                                                let v1973 = C::unpack_value_array_2(ctx, v1971);
                                                                                                if v1967.0 == v1973.0 {
                                                                                                    if v1967.1 == v1973.1 {
                                                                                                        let mut v1357 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                        C::inst_data_value_tupled_etor(ctx, v155.1, &mut v1357);
                                                                                                        let mut v1357 = v1357.into_context_iter();
                                                                                                        while let Some(v1358) = v1357.next(ctx) {
                                                                                                            let v1359 = C::iconst_sextend_etor(ctx, v1358);
                                                                                                            if let Some(v1360) = v1359 {
                                                                                                                match v1360.1 {
                                                                                                                    -1_i64 => {
                                                                                                                        let v1979 = constructor_ult(ctx, v226.0, v1967.0, v1967.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 180.
                                                                                                                        returns.extend(Some(v1979));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                    0_i64 => {
                                                                                                                        let v1976 = constructor_eq(ctx, v226.0, v1967.0, v1967.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 147.
                                                                                                                        returns.extend(Some(v1976));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                    1_i64 => {
                                                                                                                        let v1983 = constructor_ugt(ctx, v226.0, v1967.0, v1967.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 188.
                                                                                                                        returns.extend(Some(v1983));
                                                                                                                        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 v1080 = constructor_iadd(ctx, v159.0, v155.1, v205.1);
                                                                            let v1081 = constructor_eq(ctx, v2.0, v205.0, v1080);
                                                                            // Rule at src/opts/cprop.isle line 251.
                                                                            returns.extend(Some(v1081));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                if v155.1 == v205.0 {
                                                    let v296 = constructor_iconst_u(ctx, v159.0, 0x0_u64);
                                                    let v300 = constructor_eq(ctx, v2.0, v205.1, v296);
                                                    // Rule at src/opts/arithmetic.isle line 398.
                                                    returns.extend(Some(v300));
                                                    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 v1410 = constructor_iadd(ctx, v159.0, v205.0, v171.1);
                                                            let v1411 = constructor_iadd(ctx, v166.0, v171.0, v205.1);
                                                            let v1412 = constructor_eq(ctx, v2.0, v1410, v1411);
                                                            // Rule at src/opts/icmp.isle line 40.
                                                            returns.extend(Some(v1412));
                                                            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 v306,
                                                        arg: v307,
                                                    } = &v166.1 {
                                                        if let &Opcode::Bnot = v306 {
                                                            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 v937,
                                                                        arg: v938,
                                                                    } = &v209.1 {
                                                                        if let &Opcode::Bnot = v937 {
                                                                            if v307 == v938 {
                                                                                if v159.0 == v209.0 {
                                                                                    let v939 = constructor_bor(ctx, v159.0, v938, v205.0);
                                                                                    let v935 = constructor_iconst_s(ctx, v159.0, -1_i64);
                                                                                    let v940 = constructor_eq(ctx, v2.0, v939, v935);
                                                                                    // Rule at src/opts/bitops.isle line 692.
                                                                                    returns.extend(Some(v940));
                                                                                    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 v932,
                                                                        arg: v933,
                                                                    } = &v226.1 {
                                                                        if let &Opcode::Bnot = v932 {
                                                                            if v307 == v933 {
                                                                                if v159.0 == v226.0 {
                                                                                    let v934 = constructor_bor(ctx, v159.0, v933, v205.1);
                                                                                    let v935 = constructor_iconst_s(ctx, v159.0, -1_i64);
                                                                                    let v936 = constructor_eq(ctx, v2.0, v934, v935);
                                                                                    // Rule at src/opts/bitops.isle line 691.
                                                                                    returns.extend(Some(v936));
                                                                                    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 v735 = constructor_eq(ctx, v2.0, v205.1, v171.1);
                                                                    // Rule at src/opts/bitops.isle line 309.
                                                                    returns.extend(Some(v735));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    let v736 = constructor_eq(ctx, v2.0, v171.1, v205.1);
                                                                    // Rule at src/opts/bitops.isle line 310.
                                                                    returns.extend(Some(v736));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v171.0 == v205.1 {
                                                                    let v731 = constructor_eq(ctx, v2.0, v205.0, v171.1);
                                                                    // Rule at src/opts/bitops.isle line 305.
                                                                    returns.extend(Some(v731));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    let v734 = constructor_eq(ctx, v2.0, v171.1, v205.0);
                                                                    // Rule at src/opts/bitops.isle line 308.
                                                                    returns.extend(Some(v734));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v171.1 == v205.0 {
                                                                    let v732 = constructor_eq(ctx, v2.0, v171.0, v205.1);
                                                                    // Rule at src/opts/bitops.isle line 306.
                                                                    returns.extend(Some(v732));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    let v733 = constructor_eq(ctx, v2.0, v205.1, v171.0);
                                                                    // Rule at src/opts/bitops.isle line 307.
                                                                    returns.extend(Some(v733));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v171.1 == v205.1 {
                                                                    let v729 = constructor_eq(ctx, v2.0, v205.0, v171.0);
                                                                    // Rule at src/opts/bitops.isle line 303.
                                                                    returns.extend(Some(v729));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    let v730 = constructor_eq(ctx, v2.0, v171.0, v205.0);
                                                                    // Rule at src/opts/bitops.isle line 304.
                                                                    returns.extend(Some(v730));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                    &InstructionData::Ternary {
                                        opcode: ref v1530,
                                        args: ref v1531,
                                    } => {
                                        if let &Opcode::Select = v1530 {
                                            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 v1532 = C::unpack_value_array_3(ctx, v1531);
                                                        let mut v1585 = C::inst_data_value_etor_returns::default();
                                                        C::inst_data_value_etor(ctx, v1532.1, &mut v1585);
                                                        let mut v1585 = v1585.into_context_iter();
                                                        while let Some(v1586) = v1585.next(ctx) {
                                                            if let &InstructionData::UnaryImm {
                                                                opcode: ref v1589,
                                                                imm: v1590,
                                                            } = &v1586.1 {
                                                                if let &Opcode::Iconst = v1589 {
                                                                    let mut v1592 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v1532.2, &mut v1592);
                                                                    let mut v1592 = v1592.into_context_iter();
                                                                    while let Some(v1593) = v1592.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v1596,
                                                                            imm: v1597,
                                                                        } = &v1593.1 {
                                                                            if let &Opcode::Iconst = v1596 {
                                                                                let v1591 = C::u64_from_imm64(ctx, v1590);
                                                                                let v1598 = C::u64_from_imm64(ctx, v1597);
                                                                                let v1599 = C::u64_eq(ctx, v1591, v1598);
                                                                                if v1599 == false {
                                                                                    let v217 = C::u64_from_imm64(ctx, v216);
                                                                                    if v217 == v1591 {
                                                                                        let v1584 = C::value_type(ctx, v1532.0);
                                                                                        let v1600 = constructor_iconst_u(ctx, v1584, 0x0_u64);
                                                                                        let v1601 = constructor_ne(ctx, v159.0, v1532.0, v1600);
                                                                                        // Rule at src/opts/icmp.isle line 385.
                                                                                        returns.extend(Some(v1601));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v217 == v1598 {
                                                                                        let v1584 = C::value_type(ctx, v1532.0);
                                                                                        let v1600 = constructor_iconst_u(ctx, v1584, 0x0_u64);
                                                                                        let v1602 = constructor_eq(ctx, v159.0, v1532.0, v1600);
                                                                                        // Rule at src/opts/icmp.isle line 393.
                                                                                        returns.extend(Some(v1602));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    &InstructionData::Unary {
                                        opcode: ref v304,
                                        arg: v305,
                                    } => {
                                        match v304 {
                                            &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 v306,
                                                            arg: v307,
                                                        } = &v166.1 {
                                                            if let &Opcode::Ineg = v306 {
                                                                if v2.0 == v166.0 {
                                                                    let v308 = constructor_eq(ctx, v2.0, v305, v307);
                                                                    // Rule at src/opts/arithmetic.isle line 408.
                                                                    returns.extend(Some(v308));
                                                                    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 v945,
                                                                        arg: v946,
                                                                    } = &v175.1 {
                                                                        if let &Opcode::Bnot = v945 {
                                                                            if v305 == v946 {
                                                                                if v159.0 == v175.0 {
                                                                                    let v947 = constructor_bor(ctx, v159.0, v305, v171.0);
                                                                                    let v935 = constructor_iconst_s(ctx, v159.0, -1_i64);
                                                                                    let v948 = constructor_eq(ctx, v2.0, v947, v935);
                                                                                    // Rule at src/opts/bitops.isle line 694.
                                                                                    returns.extend(Some(v948));
                                                                                    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 v941,
                                                                        arg: v942,
                                                                    } = &v190.1 {
                                                                        if let &Opcode::Bnot = v941 {
                                                                            if v305 == v942 {
                                                                                if v159.0 == v190.0 {
                                                                                    let v943 = constructor_bor(ctx, v159.0, v305, v171.1);
                                                                                    let v935 = constructor_iconst_s(ctx, v159.0, -1_i64);
                                                                                    let v944 = constructor_eq(ctx, v2.0, v943, v935);
                                                                                    // Rule at src/opts/bitops.isle line 693.
                                                                                    returns.extend(Some(v944));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            &Opcode::Clz => {
                                                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 v296 = constructor_iconst_u(ctx, v159.0, 0x0_u64);
                                                                let v1608 = constructor_slt(ctx, v2.0, v305, v296);
                                                                // Rule at src/opts/icmp.isle line 446.
                                                                returns.extend(Some(v1608));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            &Opcode::Ctz => {
                                                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 v1603 = constructor_iconst_u(ctx, v159.0, 0x1_u64);
                                                                let v1604 = constructor_band(ctx, v159.0, v305, v1603);
                                                                let v1605 = constructor_iconst_u(ctx, v159.0, 0x0_u64);
                                                                let v1606 = constructor_ne(ctx, v2.0, v1604, v1605);
                                                                // Rule at src/opts/icmp.isle line 437.
                                                                returns.extend(Some(v1606));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            &Opcode::Sextend => {
                                                let mut v1357 = C::inst_data_value_tupled_etor_returns::default();
                                                C::inst_data_value_tupled_etor(ctx, v155.1, &mut v1357);
                                                let mut v1357 = v1357.into_context_iter();
                                                while let Some(v1358) = v1357.next(ctx) {
                                                    let v1359 = C::iconst_sextend_etor(ctx, v1358);
                                                    if let Some(v1360) = v1359 {
                                                        if v1360.1 == 0_i64 {
                                                            let v1353 = C::value_type(ctx, v305);
                                                            let v1364 = constructor_iconst_s(ctx, v1353, 0_i64);
                                                            let v1365 = constructor_eq(ctx, v1353, v305, v1364);
                                                            // Rule at src/opts/extends.isle line 39.
                                                            returns.extend(Some(v1365));
                                                            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 v298 = constructor_iconst_u(ctx, v166.0, 0x0_u64);
                                                    let v301 = constructor_eq(ctx, v2.0, v171.1, v298);
                                                    // Rule at src/opts/arithmetic.isle line 405.
                                                    returns.extend(Some(v301));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v155.0 == v171.1 {
                                                    let v298 = constructor_iconst_u(ctx, v166.0, 0x0_u64);
                                                    let v303 = constructor_eq(ctx, v2.0, v171.0, v298);
                                                    // Rule at src/opts/arithmetic.isle line 404.
                                                    returns.extend(Some(v303));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                            &Opcode::Isub => {
                                                let v171 = C::unpack_value_array_2(ctx, v170);
                                                if v155.0 == v171.0 {
                                                    let v298 = constructor_iconst_u(ctx, v166.0, 0x0_u64);
                                                    let v301 = constructor_eq(ctx, v2.0, v171.1, v298);
                                                    // Rule at src/opts/arithmetic.isle line 399.
                                                    returns.extend(Some(v301));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                            &Opcode::Bxor => {
                                                let v1521 = C::ty_int(ctx, v166.0);
                                                if let Some(v1522) = v1521 {
                                                    let v171 = C::unpack_value_array_2(ctx, v170);
                                                    if v155.0 == v171.0 {
                                                        let v1523 = constructor_iconst_u(ctx, v1522, 0x0_u64);
                                                        let v1524 = constructor_eq(ctx, v2.0, v171.1, v1523);
                                                        let v1525 = C::subsume(ctx, v1524);
                                                        // Rule at src/opts/icmp.isle line 294.
                                                        returns.extend(Some(v1525));
                                                        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 v1414 = C::uextend_maybe_etor_returns::default();
                                                    C::uextend_maybe_etor(ctx, v155.0, &mut v1414);
                                                    let mut v1414 = v1414.into_context_iter();
                                                    while let Some(v1415) = v1414.next(ctx) {
                                                        let mut v1418 = C::inst_data_value_etor_returns::default();
                                                        C::inst_data_value_etor(ctx, v1415.1, &mut v1418);
                                                        let mut v1418 = v1418.into_context_iter();
                                                        while let Some(v1419) = v1418.next(ctx) {
                                                            if let &InstructionData::IntCompare {
                                                                opcode: ref v1422,
                                                                args: ref v1423,
                                                                cond: ref v1424,
                                                            } = &v1419.1 {
                                                                if let &Opcode::Icmp = v1422 {
                                                                    if v2.0 == v1419.0 {
                                                                        let v1435 = &C::intcc_complement(ctx, v1424);
                                                                        let v1425 = C::unpack_value_array_2(ctx, v1423);
                                                                        let v1436 = constructor_icmp(ctx, v2.0, v1435, v1425.0, v1425.1);
                                                                        let v1437 = C::subsume(ctx, v1436);
                                                                        // Rule at src/opts/icmp.isle line 62.
                                                                        returns.extend(Some(v1437));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                0x1_u64 => {
                                                    let mut v1414 = C::uextend_maybe_etor_returns::default();
                                                    C::uextend_maybe_etor(ctx, v155.0, &mut v1414);
                                                    let mut v1414 = v1414.into_context_iter();
                                                    while let Some(v1415) = v1414.next(ctx) {
                                                        let mut v1418 = C::inst_data_value_etor_returns::default();
                                                        C::inst_data_value_etor(ctx, v1415.1, &mut v1418);
                                                        let mut v1418 = v1418.into_context_iter();
                                                        while let Some(v1419) = v1418.next(ctx) {
                                                            if let &InstructionData::IntCompare {
                                                                opcode: ref v1422,
                                                                args: ref v1423,
                                                                cond: ref v1424,
                                                            } = &v1419.1 {
                                                                if let &Opcode::Icmp = v1422 {
                                                                    let v1428 = C::subsume(ctx, v1415.1);
                                                                    // Rule at src/opts/icmp.isle line 76.
                                                                    returns.extend(Some(v1428));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                _ => {}
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                            if v155.0 == v155.1 {
                                let v344 = C::ty_int(ctx, v2.0);
                                if let Some(v345) = v344 {
                                    let v1400 = constructor_iconst_u(ctx, v345, 0x1_u64);
                                    let v1401 = C::subsume(ctx, v1400);
                                    // Rule at src/opts/icmp.isle line 4.
                                    returns.extend(Some(v1401));
                                    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 v827 = constructor_ne(ctx, v2.0, v205.1, v171.1);
                                                                    let v1409 = C::subsume(ctx, v827);
                                                                    // Rule at src/opts/icmp.isle line 34.
                                                                    returns.extend(Some(v1409));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v171.0 == v205.1 {
                                                                    let v823 = constructor_ne(ctx, v2.0, v205.0, v171.1);
                                                                    let v1407 = C::subsume(ctx, v823);
                                                                    // Rule at src/opts/icmp.isle line 30.
                                                                    returns.extend(Some(v1407));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v171.1 == v205.0 {
                                                                    let v825 = constructor_ne(ctx, v2.0, v205.1, v171.0);
                                                                    let v1408 = C::subsume(ctx, v825);
                                                                    // Rule at src/opts/icmp.isle line 32.
                                                                    returns.extend(Some(v1408));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v171.1 == v205.1 {
                                                                    let v821 = constructor_ne(ctx, v2.0, v205.0, v171.0);
                                                                    let v1406 = C::subsume(ctx, v821);
                                                                    // Rule at src/opts/icmp.isle line 28.
                                                                    returns.extend(Some(v1406));
                                                                    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 v1083 = constructor_isub(ctx, v166.0, v171.1, v205.1);
                                                                                        let v1084 = constructor_iadd(ctx, v159.0, v171.0, v1083);
                                                                                        let v1086 = constructor_ne(ctx, v2.0, v205.0, v1084);
                                                                                        // Rule at src/opts/cprop.isle line 258.
                                                                                        returns.extend(Some(v1086));
                                                                                        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 v1077 = constructor_isub(ctx, v159.0, v155.1, v205.1);
                                                                            let v1079 = constructor_ne(ctx, v2.0, v205.0, v1077);
                                                                            // Rule at src/opts/cprop.isle line 248.
                                                                            returns.extend(Some(v1079));
                                                                            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 v1970,
                                                            args: ref v1971,
                                                            cond: ref v1972,
                                                        } => {
                                                            if let &Opcode::Icmp = v1970 {
                                                                match v1972 {
                                                                    &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 v1964,
                                                                                    args: ref v1965,
                                                                                    cond: ref v1966,
                                                                                } = &v226.1 {
                                                                                    if let &Opcode::Icmp = v1964 {
                                                                                        if let &IntCC::SignedGreaterThan = v1966 {
                                                                                            if v209.0 == v226.0 {
                                                                                                let v1967 = C::unpack_value_array_2(ctx, v1965);
                                                                                                let v1973 = C::unpack_value_array_2(ctx, v1971);
                                                                                                if v1967.0 == v1973.0 {
                                                                                                    if v1967.1 == v1973.1 {
                                                                                                        let mut v1357 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                        C::inst_data_value_tupled_etor(ctx, v155.1, &mut v1357);
                                                                                                        let mut v1357 = v1357.into_context_iter();
                                                                                                        while let Some(v1358) = v1357.next(ctx) {
                                                                                                            let v1359 = C::iconst_sextend_etor(ctx, v1358);
                                                                                                            if let Some(v1360) = v1359 {
                                                                                                                match v1360.1 {
                                                                                                                    -1_i64 => {
                                                                                                                        let v1984 = constructor_sge(ctx, v226.0, v1967.0, v1967.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 182.
                                                                                                                        returns.extend(Some(v1984));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                    0_i64 => {
                                                                                                                        let v1977 = constructor_ne(ctx, v226.0, v1967.0, v1967.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 150.
                                                                                                                        returns.extend(Some(v1977));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                    1_i64 => {
                                                                                                                        let v1980 = constructor_sle(ctx, v226.0, v1967.0, v1967.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 190.
                                                                                                                        returns.extend(Some(v1980));
                                                                                                                        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 v1964,
                                                                                    args: ref v1965,
                                                                                    cond: ref v1966,
                                                                                } = &v226.1 {
                                                                                    if let &Opcode::Icmp = v1964 {
                                                                                        if let &IntCC::UnsignedGreaterThan = v1966 {
                                                                                            if v209.0 == v226.0 {
                                                                                                let v1967 = C::unpack_value_array_2(ctx, v1965);
                                                                                                let v1973 = C::unpack_value_array_2(ctx, v1971);
                                                                                                if v1967.0 == v1973.0 {
                                                                                                    if v1967.1 == v1973.1 {
                                                                                                        let mut v1357 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                        C::inst_data_value_tupled_etor(ctx, v155.1, &mut v1357);
                                                                                                        let mut v1357 = v1357.into_context_iter();
                                                                                                        while let Some(v1358) = v1357.next(ctx) {
                                                                                                            let v1359 = C::iconst_sextend_etor(ctx, v1358);
                                                                                                            if let Some(v1360) = v1359 {
                                                                                                                match v1360.1 {
                                                                                                                    -1_i64 => {
                                                                                                                        let v1985 = constructor_uge(ctx, v226.0, v1967.0, v1967.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 184.
                                                                                                                        returns.extend(Some(v1985));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                    0_i64 => {
                                                                                                                        let v1977 = constructor_ne(ctx, v226.0, v1967.0, v1967.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 152.
                                                                                                                        returns.extend(Some(v1977));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                    1_i64 => {
                                                                                                                        let v1981 = constructor_ule(ctx, v226.0, v1967.0, v1967.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 192.
                                                                                                                        returns.extend(Some(v1981));
                                                                                                                        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 v1080 = constructor_iadd(ctx, v159.0, v155.1, v205.1);
                                                                            let v1082 = constructor_ne(ctx, v2.0, v205.0, v1080);
                                                                            // Rule at src/opts/cprop.isle line 253.
                                                                            returns.extend(Some(v1082));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                if v155.1 == v205.0 {
                                                    let v296 = constructor_iconst_u(ctx, v159.0, 0x0_u64);
                                                    let v297 = constructor_ne(ctx, v2.0, v205.1, v296);
                                                    // Rule at src/opts/arithmetic.isle line 394.
                                                    returns.extend(Some(v297));
                                                    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 v1410 = constructor_iadd(ctx, v159.0, v205.0, v171.1);
                                                            let v1411 = constructor_iadd(ctx, v166.0, v171.0, v205.1);
                                                            let v1413 = constructor_ne(ctx, v2.0, v1410, v1411);
                                                            // Rule at src/opts/icmp.isle line 42.
                                                            returns.extend(Some(v1413));
                                                            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 v827 = constructor_ne(ctx, v2.0, v205.1, v171.1);
                                                                    // Rule at src/opts/bitops.isle line 460.
                                                                    returns.extend(Some(v827));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    let v828 = constructor_ne(ctx, v2.0, v171.1, v205.1);
                                                                    // Rule at src/opts/bitops.isle line 461.
                                                                    returns.extend(Some(v828));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v171.0 == v205.1 {
                                                                    let v823 = constructor_ne(ctx, v2.0, v205.0, v171.1);
                                                                    // Rule at src/opts/bitops.isle line 456.
                                                                    returns.extend(Some(v823));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    let v826 = constructor_ne(ctx, v2.0, v171.1, v205.0);
                                                                    // Rule at src/opts/bitops.isle line 459.
                                                                    returns.extend(Some(v826));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v171.1 == v205.0 {
                                                                    let v824 = constructor_ne(ctx, v2.0, v171.0, v205.1);
                                                                    // Rule at src/opts/bitops.isle line 457.
                                                                    returns.extend(Some(v824));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    let v825 = constructor_ne(ctx, v2.0, v205.1, v171.0);
                                                                    // Rule at src/opts/bitops.isle line 458.
                                                                    returns.extend(Some(v825));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v171.1 == v205.1 {
                                                                    let v821 = constructor_ne(ctx, v2.0, v205.0, v171.0);
                                                                    // Rule at src/opts/bitops.isle line 454.
                                                                    returns.extend(Some(v821));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    let v822 = constructor_ne(ctx, v2.0, v171.0, v205.0);
                                                                    // Rule at src/opts/bitops.isle line 455.
                                                                    returns.extend(Some(v822));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                    &InstructionData::Ternary {
                                        opcode: ref v1530,
                                        args: ref v1531,
                                    } => {
                                        if let &Opcode::Select = v1530 {
                                            let v1532 = C::unpack_value_array_3(ctx, v1531);
                                            if v155.1 == v1532.1 {
                                                let mut v1536 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v1532.0, &mut v1536);
                                                let mut v1536 = v1536.into_context_iter();
                                                while let Some(v1537) = v1536.next(ctx) {
                                                    if let &InstructionData::IntCompare {
                                                        opcode: ref v1540,
                                                        args: ref v1541,
                                                        cond: ref v1542,
                                                    } = &v1537.1 {
                                                        if let &Opcode::Icmp = v1540 {
                                                            match v1542 {
                                                                &IntCC::SignedLessThan => {
                                                                    if v2.0 == v1537.0 {
                                                                        let v1543 = C::unpack_value_array_2(ctx, v1541);
                                                                        if v155.1 == v1543.0 {
                                                                            if v1532.2 == v1543.1 {
                                                                                let v1546 = constructor_sgt(ctx, v2.0, v1543.0, v1543.1);
                                                                                // Rule at src/opts/icmp.isle line 302.
                                                                                returns.extend(Some(v1546));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &IntCC::UnsignedLessThan => {
                                                                    if v2.0 == v1537.0 {
                                                                        let v1543 = C::unpack_value_array_2(ctx, v1541);
                                                                        if v155.1 == v1543.0 {
                                                                            if v1532.2 == v1543.1 {
                                                                                let v1547 = constructor_ugt(ctx, v2.0, v1543.0, v1543.1);
                                                                                // Rule at src/opts/icmp.isle line 303.
                                                                                returns.extend(Some(v1547));
                                                                                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 v1585 = C::inst_data_value_etor_returns::default();
                                                        C::inst_data_value_etor(ctx, v1532.1, &mut v1585);
                                                        let mut v1585 = v1585.into_context_iter();
                                                        while let Some(v1586) = v1585.next(ctx) {
                                                            if let &InstructionData::UnaryImm {
                                                                opcode: ref v1589,
                                                                imm: v1590,
                                                            } = &v1586.1 {
                                                                if let &Opcode::Iconst = v1589 {
                                                                    let mut v1592 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v1532.2, &mut v1592);
                                                                    let mut v1592 = v1592.into_context_iter();
                                                                    while let Some(v1593) = v1592.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v1596,
                                                                            imm: v1597,
                                                                        } = &v1593.1 {
                                                                            if let &Opcode::Iconst = v1596 {
                                                                                let v1591 = C::u64_from_imm64(ctx, v1590);
                                                                                let v1598 = C::u64_from_imm64(ctx, v1597);
                                                                                let v1599 = C::u64_eq(ctx, v1591, v1598);
                                                                                if v1599 == false {
                                                                                    let v217 = C::u64_from_imm64(ctx, v216);
                                                                                    if v217 == v1591 {
                                                                                        let v1584 = C::value_type(ctx, v1532.0);
                                                                                        let v1600 = constructor_iconst_u(ctx, v1584, 0x0_u64);
                                                                                        let v1602 = constructor_eq(ctx, v159.0, v1532.0, v1600);
                                                                                        // Rule at src/opts/icmp.isle line 401.
                                                                                        returns.extend(Some(v1602));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v217 == v1598 {
                                                                                        let v1584 = C::value_type(ctx, v1532.0);
                                                                                        let v1600 = constructor_iconst_u(ctx, v1584, 0x0_u64);
                                                                                        let v1601 = constructor_ne(ctx, v159.0, v1532.0, v1600);
                                                                                        // Rule at src/opts/icmp.isle line 409.
                                                                                        returns.extend(Some(v1601));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    &InstructionData::Unary {
                                        opcode: ref v304,
                                        arg: v305,
                                    } => {
                                        match v304 {
                                            &Opcode::Clz => {
                                                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 v296 = constructor_iconst_u(ctx, v159.0, 0x0_u64);
                                                                let v1609 = constructor_sge(ctx, v2.0, v305, v296);
                                                                // Rule at src/opts/icmp.isle line 450.
                                                                returns.extend(Some(v1609));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            &Opcode::Ctz => {
                                                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 v1603 = constructor_iconst_u(ctx, v159.0, 0x1_u64);
                                                                let v1604 = constructor_band(ctx, v159.0, v305, v1603);
                                                                let v1605 = constructor_iconst_u(ctx, v159.0, 0x0_u64);
                                                                let v1607 = constructor_eq(ctx, v2.0, v1604, v1605);
                                                                // Rule at src/opts/icmp.isle line 441.
                                                                returns.extend(Some(v1607));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            &Opcode::Sextend => {
                                                let mut v1357 = C::inst_data_value_tupled_etor_returns::default();
                                                C::inst_data_value_tupled_etor(ctx, v155.1, &mut v1357);
                                                let mut v1357 = v1357.into_context_iter();
                                                while let Some(v1358) = v1357.next(ctx) {
                                                    let v1359 = C::iconst_sextend_etor(ctx, v1358);
                                                    if let Some(v1360) = v1359 {
                                                        if v1360.1 == 0_i64 {
                                                            let v1353 = C::value_type(ctx, v305);
                                                            let v1364 = constructor_iconst_s(ctx, v1353, 0_i64);
                                                            let v1366 = constructor_ne(ctx, v1353, v305, v1364);
                                                            // Rule at src/opts/extends.isle line 41.
                                                            returns.extend(Some(v1366));
                                                            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,
                                    } => {
                                        match v169 {
                                            &Opcode::Isub => {
                                                let v171 = C::unpack_value_array_2(ctx, v170);
                                                if v155.0 == v171.0 {
                                                    let v298 = constructor_iconst_u(ctx, v166.0, 0x0_u64);
                                                    let v299 = constructor_ne(ctx, v2.0, v171.1, v298);
                                                    // Rule at src/opts/arithmetic.isle line 395.
                                                    returns.extend(Some(v299));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                            &Opcode::Bxor => {
                                                let v1521 = C::ty_int(ctx, v166.0);
                                                if let Some(v1522) = v1521 {
                                                    let v171 = C::unpack_value_array_2(ctx, v170);
                                                    if v155.0 == v171.0 {
                                                        let v1523 = constructor_iconst_u(ctx, v1522, 0x0_u64);
                                                        let v1526 = constructor_ne(ctx, v2.0, v171.1, v1523);
                                                        let v1527 = C::subsume(ctx, v1526);
                                                        // Rule at src/opts/icmp.isle line 295.
                                                        returns.extend(Some(v1527));
                                                        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 v1414 = C::uextend_maybe_etor_returns::default();
                                                    C::uextend_maybe_etor(ctx, v155.0, &mut v1414);
                                                    let mut v1414 = v1414.into_context_iter();
                                                    while let Some(v1415) = v1414.next(ctx) {
                                                        let mut v1418 = C::inst_data_value_etor_returns::default();
                                                        C::inst_data_value_etor(ctx, v1415.1, &mut v1418);
                                                        let mut v1418 = v1418.into_context_iter();
                                                        while let Some(v1419) = v1418.next(ctx) {
                                                            match &v1419.1 {
                                                                &InstructionData::FloatCompare {
                                                                    opcode: ref v1429,
                                                                    args: ref v1430,
                                                                    cond: ref v1431,
                                                                } => {
                                                                    if let &Opcode::Fcmp = v1429 {
                                                                        if v2.0 == v1419.0 {
                                                                            let v1428 = C::subsume(ctx, v1415.1);
                                                                            // Rule at src/opts/icmp.isle line 55.
                                                                            returns.extend(Some(v1428));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                &InstructionData::IntCompare {
                                                                    opcode: ref v1422,
                                                                    args: ref v1423,
                                                                    cond: ref v1424,
                                                                } => {
                                                                    if let &Opcode::Icmp = v1422 {
                                                                        if v2.0 == v1419.0 {
                                                                            let v1428 = C::subsume(ctx, v1415.1);
                                                                            // Rule at src/opts/icmp.isle line 48.
                                                                            returns.extend(Some(v1428));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                    }
                                                    let mut v381 = ContextIterWrapper::<ConstructorVec<_>, _>::default();
                                                    constructor_truthy(ctx, v155.0, &mut v381);
                                                    let mut v381 = v381.into_context_iter();
                                                    while let Some(v382) = v381.next(ctx) {
                                                        let v383 = C::value_type(ctx, v382);
                                                        let v384 = C::ty_int_ref_scalar_64_extract(ctx, v383);
                                                        if let Some(v385) = v384 {
                                                            let v386 = constructor_iconst_u(ctx, v385, 0x0_u64);
                                                            let v387 = constructor_ne(ctx, v2.0, v382, v386);
                                                            // Rule at src/opts/bitops.isle line 114.
                                                            returns.extend(Some(v387));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                                0x1_u64 => {
                                                    let mut v1414 = C::uextend_maybe_etor_returns::default();
                                                    C::uextend_maybe_etor(ctx, v155.0, &mut v1414);
                                                    let mut v1414 = v1414.into_context_iter();
                                                    while let Some(v1415) = v1414.next(ctx) {
                                                        let mut v1418 = C::inst_data_value_etor_returns::default();
                                                        C::inst_data_value_etor(ctx, v1415.1, &mut v1418);
                                                        let mut v1418 = v1418.into_context_iter();
                                                        while let Some(v1419) = v1418.next(ctx) {
                                                            if let &InstructionData::IntCompare {
                                                                opcode: ref v1422,
                                                                args: ref v1423,
                                                                cond: ref v1424,
                                                            } = &v1419.1 {
                                                                if let &Opcode::Icmp = v1422 {
                                                                    if v2.0 == v1419.0 {
                                                                        let v1435 = &C::intcc_complement(ctx, v1424);
                                                                        let v1425 = C::unpack_value_array_2(ctx, v1423);
                                                                        let v1436 = constructor_icmp(ctx, v2.0, v1435, v1425.0, v1425.1);
                                                                        let v1437 = C::subsume(ctx, v1436);
                                                                        // Rule at src/opts/icmp.isle line 69.
                                                                        returns.extend(Some(v1437));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                _ => {}
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                            if v155.0 == v155.1 {
                                let v344 = C::ty_int(ctx, v2.0);
                                if let Some(v345) = v344 {
                                    let v346 = constructor_iconst_u(ctx, v345, 0x0_u64);
                                    let v347 = C::subsume(ctx, v346);
                                    // Rule at src/opts/icmp.isle line 5.
                                    returns.extend(Some(v347));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                        }
                        &IntCC::SignedGreaterThan => {
                            let v339 = C::fits_in_64(ctx, v2.0);
                            if let Some(v340) = v339 {
                                let v1455 = C::ty_int(ctx, v340);
                                if let Some(v1456) = v1455 {
                                    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 v1466 = C::ty_smin(ctx, v166.0);
                                                let v1467 = C::u64_eq(ctx, v217, v1466);
                                                if v1467 == true {
                                                    let v1458 = constructor_ne(ctx, v1456, v155.0, v155.1);
                                                    // Rule at src/opts/icmp.isle line 149.
                                                    returns.extend(Some(v1458));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let v1468 = C::ty_smax(ctx, v166.0);
                                                let v1469 = C::u64_eq(ctx, v217, v1468);
                                                if v1469 == true {
                                                    let v1464 = constructor_iconst_u(ctx, v1456, 0x0_u64);
                                                    let v1465 = C::subsume(ctx, v1464);
                                                    // Rule at src/opts/icmp.isle line 169.
                                                    returns.extend(Some(v1465));
                                                    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 v1711 = constructor_iconst_u(ctx, v340, 0x0_u64);
                                                // Rule at src/opts/selects.isle line 105.
                                                returns.extend(Some(v1711));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            if v155.1 == v205.1 {
                                                let v1711 = constructor_iconst_u(ctx, v340, 0x0_u64);
                                                // Rule at src/opts/selects.isle line 106.
                                                returns.extend(Some(v1711));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                }
                            }
                            let v155 = C::unpack_value_array_2(ctx, v153);
                            let mut v1357 = C::inst_data_value_tupled_etor_returns::default();
                            C::inst_data_value_tupled_etor(ctx, v155.1, &mut v1357);
                            let mut v1357 = v1357.into_context_iter();
                            while let Some(v1358) = v1357.next(ctx) {
                                let v1359 = C::iconst_sextend_etor(ctx, v1358);
                                if let Some(v1360) = v1359 {
                                    match v1360.1 {
                                        -1_i64 => {
                                            let v1480 = constructor_iconst_s(ctx, v1360.0, 0_i64);
                                            let v1483 = constructor_sge(ctx, v2.0, v155.0, v1480);
                                            // Rule at src/opts/icmp.isle line 201.
                                            returns.extend(Some(v1483));
                                            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 v1970,
                                                                    args: ref v1971,
                                                                    cond: ref v1972,
                                                                } = &v209.1 {
                                                                    if let &Opcode::Icmp = v1970 {
                                                                        match v1972 {
                                                                            &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 v1964,
                                                                                        args: ref v1965,
                                                                                        cond: ref v1966,
                                                                                    } = &v226.1 {
                                                                                        if let &Opcode::Icmp = v1964 {
                                                                                            if let &IntCC::SignedGreaterThan = v1966 {
                                                                                                if v209.0 == v226.0 {
                                                                                                    let v1967 = C::unpack_value_array_2(ctx, v1965);
                                                                                                    let v1973 = C::unpack_value_array_2(ctx, v1971);
                                                                                                    if v1967.0 == v1973.0 {
                                                                                                        if v1967.1 == v1973.1 {
                                                                                                            let v1982 = constructor_sgt(ctx, v226.0, v1967.0, v1967.1);
                                                                                                            // Rule at src/opts/spaceship.isle line 166.
                                                                                                            returns.extend(Some(v1982));
                                                                                                            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 v1964,
                                                                                        args: ref v1965,
                                                                                        cond: ref v1966,
                                                                                    } = &v226.1 {
                                                                                        if let &Opcode::Icmp = v1964 {
                                                                                            if let &IntCC::UnsignedGreaterThan = v1966 {
                                                                                                if v209.0 == v226.0 {
                                                                                                    let v1967 = C::unpack_value_array_2(ctx, v1965);
                                                                                                    let v1973 = C::unpack_value_array_2(ctx, v1971);
                                                                                                    if v1967.0 == v1973.0 {
                                                                                                        if v1967.1 == v1973.1 {
                                                                                                            let v1983 = constructor_ugt(ctx, v226.0, v1967.0, v1967.1);
                                                                                                            // Rule at src/opts/spaceship.isle line 168.
                                                                                                            returns.extend(Some(v1983));
                                                                                                            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 561.
                                                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 562.
                                                returns.extend(Some(v53));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                }
                            }
                            let v344 = C::ty_int(ctx, v2.0);
                            if let Some(v345) = v344 {
                                if v155.0 == v155.1 {
                                    let v346 = constructor_iconst_u(ctx, v345, 0x0_u64);
                                    let v347 = C::subsume(ctx, v346);
                                    // Rule at src/opts/icmp.isle line 8.
                                    returns.extend(Some(v347));
                                    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 v295 = constructor_cmp_true(ctx, v2.0);
                                                        // Rule at src/opts/arithmetic.isle line 415.
                                                        returns.extend(Some(v295));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                    if v155.1 == v205.1 {
                                                        let v295 = constructor_cmp_true(ctx, v2.0);
                                                        // Rule at src/opts/arithmetic.isle line 416.
                                                        returns.extend(Some(v295));
                                                        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 v1970,
                                                            args: ref v1971,
                                                            cond: ref v1972,
                                                        } = &v209.1 {
                                                            if let &Opcode::Icmp = v1970 {
                                                                match v1972 {
                                                                    &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 v1964,
                                                                                args: ref v1965,
                                                                                cond: ref v1966,
                                                                            } = &v226.1 {
                                                                                if let &Opcode::Icmp = v1964 {
                                                                                    if let &IntCC::SignedGreaterThan = v1966 {
                                                                                        if v209.0 == v226.0 {
                                                                                            let v1967 = C::unpack_value_array_2(ctx, v1965);
                                                                                            let v1973 = C::unpack_value_array_2(ctx, v1971);
                                                                                            if v1967.0 == v1973.0 {
                                                                                                if v1967.1 == v1973.1 {
                                                                                                    let mut v1357 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                    C::inst_data_value_tupled_etor(ctx, v155.1, &mut v1357);
                                                                                                    let mut v1357 = v1357.into_context_iter();
                                                                                                    while let Some(v1358) = v1357.next(ctx) {
                                                                                                        let v1359 = C::iconst_sextend_etor(ctx, v1358);
                                                                                                        if let Some(v1360) = v1359 {
                                                                                                            if v1360.1 == 0_i64 {
                                                                                                                let v1984 = constructor_sge(ctx, v226.0, v1967.0, v1967.1);
                                                                                                                // Rule at src/opts/spaceship.isle line 171.
                                                                                                                returns.extend(Some(v1984));
                                                                                                                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 v1964,
                                                                                args: ref v1965,
                                                                                cond: ref v1966,
                                                                            } = &v226.1 {
                                                                                if let &Opcode::Icmp = v1964 {
                                                                                    if let &IntCC::UnsignedGreaterThan = v1966 {
                                                                                        if v209.0 == v226.0 {
                                                                                            let v1967 = C::unpack_value_array_2(ctx, v1965);
                                                                                            let v1973 = C::unpack_value_array_2(ctx, v1971);
                                                                                            if v1967.0 == v1973.0 {
                                                                                                if v1967.1 == v1973.1 {
                                                                                                    let mut v1357 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                    C::inst_data_value_tupled_etor(ctx, v155.1, &mut v1357);
                                                                                                    let mut v1357 = v1357.into_context_iter();
                                                                                                    while let Some(v1358) = v1357.next(ctx) {
                                                                                                        let v1359 = C::iconst_sextend_etor(ctx, v1358);
                                                                                                        if let Some(v1360) = v1359 {
                                                                                                            if v1360.1 == 0_i64 {
                                                                                                                let v1985 = constructor_uge(ctx, v226.0, v1967.0, v1967.1);
                                                                                                                // Rule at src/opts/spaceship.isle line 173.
                                                                                                                returns.extend(Some(v1985));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                    &InstructionData::Unary {
                                        opcode: ref v304,
                                        arg: v305,
                                    } => {
                                        if let &Opcode::Uextend = v304 {
                                            if v159.0 == I64 {
                                                let v1353 = C::value_type(ctx, v305);
                                                if v1353 == 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 v1355 = constructor_iconst_u(ctx, v2.0, 0x1_u64);
                                                                    let v1356 = C::subsume(ctx, v1355);
                                                                    // Rule at src/opts/extends.isle line 32.
                                                                    returns.extend(Some(v1356));
                                                                    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 v295 = constructor_cmp_true(ctx, v2.0);
                                                    // Rule at src/opts/arithmetic.isle line 425.
                                                    returns.extend(Some(v295));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v155.0 == v171.1 {
                                                    let v295 = constructor_cmp_true(ctx, v2.0);
                                                    // Rule at src/opts/arithmetic.isle line 426.
                                                    returns.extend(Some(v295));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                    &InstructionData::UnaryImm {
                                        opcode: ref v215,
                                        imm: v216,
                                    } => {
                                        if let &Opcode::Iconst = v215 {
                                            let v339 = C::fits_in_64(ctx, v2.0);
                                            if let Some(v340) = v339 {
                                                let v1455 = C::ty_int(ctx, v340);
                                                if let Some(v1456) = v1455 {
                                                    let v217 = C::u64_from_imm64(ctx, v216);
                                                    let v1466 = C::ty_smin(ctx, v166.0);
                                                    let v1467 = C::u64_eq(ctx, v217, v1466);
                                                    if v1467 == true {
                                                        let v1462 = constructor_iconst_u(ctx, v1456, 0x1_u64);
                                                        let v1463 = C::subsume(ctx, v1462);
                                                        // Rule at src/opts/icmp.isle line 154.
                                                        returns.extend(Some(v1463));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                    let v1468 = C::ty_smax(ctx, v166.0);
                                                    let v1469 = C::u64_eq(ctx, v217, v1468);
                                                    if v1469 == true {
                                                        let v1457 = constructor_eq(ctx, v1456, v155.0, v155.1);
                                                        // Rule at src/opts/icmp.isle line 174.
                                                        returns.extend(Some(v1457));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                            if v155.0 == v155.1 {
                                let v344 = C::ty_int(ctx, v2.0);
                                if let Some(v345) = v344 {
                                    let v1400 = constructor_iconst_u(ctx, v345, 0x1_u64);
                                    let v1401 = C::subsume(ctx, v1400);
                                    // Rule at src/opts/icmp.isle line 9.
                                    returns.extend(Some(v1401));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                            let mut v1357 = C::inst_data_value_tupled_etor_returns::default();
                            C::inst_data_value_tupled_etor(ctx, v155.1, &mut v1357);
                            let mut v1357 = v1357.into_context_iter();
                            while let Some(v1358) = v1357.next(ctx) {
                                let v1359 = C::iconst_sextend_etor(ctx, v1358);
                                if let Some(v1360) = v1359 {
                                    if v1360.1 == 1_i64 {
                                        let v1480 = constructor_iconst_s(ctx, v1360.0, 0_i64);
                                        let v1481 = constructor_sgt(ctx, v2.0, v155.0, v1480);
                                        // Rule at src/opts/icmp.isle line 195.
                                        returns.extend(Some(v1481));
                                        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 563.
                                                        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 564.
                                                        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 v1970,
                                                            args: ref v1971,
                                                            cond: ref v1972,
                                                        } = &v209.1 {
                                                            if let &Opcode::Icmp = v1970 {
                                                                match v1972 {
                                                                    &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 v1964,
                                                                                args: ref v1965,
                                                                                cond: ref v1966,
                                                                            } = &v226.1 {
                                                                                if let &Opcode::Icmp = v1964 {
                                                                                    if let &IntCC::SignedGreaterThan = v1966 {
                                                                                        if v209.0 == v226.0 {
                                                                                            let v1967 = C::unpack_value_array_2(ctx, v1965);
                                                                                            let v1973 = C::unpack_value_array_2(ctx, v1971);
                                                                                            if v1967.0 == v1973.0 {
                                                                                                if v1967.1 == v1973.1 {
                                                                                                    let mut v1357 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                    C::inst_data_value_tupled_etor(ctx, v155.1, &mut v1357);
                                                                                                    let mut v1357 = v1357.into_context_iter();
                                                                                                    while let Some(v1358) = v1357.next(ctx) {
                                                                                                        let v1359 = C::iconst_sextend_etor(ctx, v1358);
                                                                                                        if let Some(v1360) = v1359 {
                                                                                                            if v1360.1 == 0_i64 {
                                                                                                                let v1978 = constructor_slt(ctx, v226.0, v1967.0, v1967.1);
                                                                                                                // Rule at src/opts/spaceship.isle line 156.
                                                                                                                returns.extend(Some(v1978));
                                                                                                                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 v1964,
                                                                                args: ref v1965,
                                                                                cond: ref v1966,
                                                                            } = &v226.1 {
                                                                                if let &Opcode::Icmp = v1964 {
                                                                                    if let &IntCC::UnsignedGreaterThan = v1966 {
                                                                                        if v209.0 == v226.0 {
                                                                                            let v1967 = C::unpack_value_array_2(ctx, v1965);
                                                                                            let v1973 = C::unpack_value_array_2(ctx, v1971);
                                                                                            if v1967.0 == v1973.0 {
                                                                                                if v1967.1 == v1973.1 {
                                                                                                    let mut v1357 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                    C::inst_data_value_tupled_etor(ctx, v155.1, &mut v1357);
                                                                                                    let mut v1357 = v1357.into_context_iter();
                                                                                                    while let Some(v1358) = v1357.next(ctx) {
                                                                                                        let v1359 = C::iconst_sextend_etor(ctx, v1358);
                                                                                                        if let Some(v1360) = v1359 {
                                                                                                            if v1360.1 == 0_i64 {
                                                                                                                let v1979 = constructor_ult(ctx, v226.0, v1967.0, v1967.1);
                                                                                                                // Rule at src/opts/spaceship.isle line 158.
                                                                                                                returns.extend(Some(v1979));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                    &InstructionData::Unary {
                                        opcode: ref v304,
                                        arg: v305,
                                    } => {
                                        match v304 {
                                            &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 v306,
                                                        arg: v307,
                                                    } = &v166.1 {
                                                        if let &Opcode::Bnot = v306 {
                                                            if v159.0 == v166.0 {
                                                                let v1549 = constructor_sgt(ctx, v2.0, v305, v307);
                                                                // Rule at src/opts/icmp.isle line 306.
                                                                returns.extend(Some(v1549));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            &Opcode::Uextend => {
                                                if v159.0 == I64 {
                                                    let v1353 = C::value_type(ctx, v305);
                                                    if v1353 == 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 v339 = C::fits_in_64(ctx, v2.0);
                            if let Some(v340) = v339 {
                                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 v1711 = constructor_iconst_u(ctx, v340, 0x0_u64);
                                                    // Rule at src/opts/selects.isle line 107.
                                                    returns.extend(Some(v1711));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v155.0 == v171.1 {
                                                    let v1711 = constructor_iconst_u(ctx, v340, 0x0_u64);
                                                    // Rule at src/opts/selects.isle line 108.
                                                    returns.extend(Some(v1711));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        &InstructionData::UnaryImm {
                                            opcode: ref v215,
                                            imm: v216,
                                        } => {
                                            if let &Opcode::Iconst = v215 {
                                                let v1455 = C::ty_int(ctx, v340);
                                                if let Some(v1456) = v1455 {
                                                    let v217 = C::u64_from_imm64(ctx, v216);
                                                    let v1466 = C::ty_smin(ctx, v166.0);
                                                    let v1467 = C::u64_eq(ctx, v217, v1466);
                                                    if v1467 == true {
                                                        let v1464 = constructor_iconst_u(ctx, v1456, 0x0_u64);
                                                        let v1465 = C::subsume(ctx, v1464);
                                                        // Rule at src/opts/icmp.isle line 139.
                                                        returns.extend(Some(v1465));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                    let v1468 = C::ty_smax(ctx, v166.0);
                                                    let v1469 = C::u64_eq(ctx, v217, v1468);
                                                    if v1469 == true {
                                                        let v1458 = constructor_ne(ctx, v1456, v155.0, v155.1);
                                                        // Rule at src/opts/icmp.isle line 159.
                                                        returns.extend(Some(v1458));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                            }
                            let v344 = C::ty_int(ctx, v2.0);
                            if let Some(v345) = v344 {
                                if v155.0 == v155.1 {
                                    let v346 = constructor_iconst_u(ctx, v345, 0x0_u64);
                                    let v347 = C::subsume(ctx, v346);
                                    // Rule at src/opts/icmp.isle line 12.
                                    returns.extend(Some(v347));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                            let mut v1357 = C::inst_data_value_tupled_etor_returns::default();
                            C::inst_data_value_tupled_etor(ctx, v155.1, &mut v1357);
                            let mut v1357 = v1357.into_context_iter();
                            while let Some(v1358) = v1357.next(ctx) {
                                let v1359 = C::iconst_sextend_etor(ctx, v1358);
                                if let Some(v1360) = v1359 {
                                    if v1360.1 == 1_i64 {
                                        let v1480 = constructor_iconst_s(ctx, v1360.0, 0_i64);
                                        let v1482 = constructor_sle(ctx, v2.0, v155.0, v1480);
                                        // Rule at src/opts/icmp.isle line 198.
                                        returns.extend(Some(v1482));
                                        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 v295 = constructor_cmp_true(ctx, v2.0);
                                                    // Rule at src/opts/arithmetic.isle line 427.
                                                    returns.extend(Some(v295));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v155.1 == v205.1 {
                                                    let v295 = constructor_cmp_true(ctx, v2.0);
                                                    // Rule at src/opts/arithmetic.isle line 428.
                                                    returns.extend(Some(v295));
                                                    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 v1970,
                                                        args: ref v1971,
                                                        cond: ref v1972,
                                                    } = &v209.1 {
                                                        if let &Opcode::Icmp = v1970 {
                                                            match v1972 {
                                                                &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 v1964,
                                                                            args: ref v1965,
                                                                            cond: ref v1966,
                                                                        } = &v226.1 {
                                                                            if let &Opcode::Icmp = v1964 {
                                                                                if let &IntCC::SignedGreaterThan = v1966 {
                                                                                    if v209.0 == v226.0 {
                                                                                        let v1967 = C::unpack_value_array_2(ctx, v1965);
                                                                                        let v1973 = C::unpack_value_array_2(ctx, v1971);
                                                                                        if v1967.0 == v1973.0 {
                                                                                            if v1967.1 == v1973.1 {
                                                                                                let mut v1357 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                C::inst_data_value_tupled_etor(ctx, v155.1, &mut v1357);
                                                                                                let mut v1357 = v1357.into_context_iter();
                                                                                                while let Some(v1358) = v1357.next(ctx) {
                                                                                                    let v1359 = C::iconst_sextend_etor(ctx, v1358);
                                                                                                    if let Some(v1360) = v1359 {
                                                                                                        if v1360.1 == 0_i64 {
                                                                                                            let v1980 = constructor_sle(ctx, v226.0, v1967.0, v1967.1);
                                                                                                            // Rule at src/opts/spaceship.isle line 161.
                                                                                                            returns.extend(Some(v1980));
                                                                                                            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 v1964,
                                                                            args: ref v1965,
                                                                            cond: ref v1966,
                                                                        } = &v226.1 {
                                                                            if let &Opcode::Icmp = v1964 {
                                                                                if let &IntCC::UnsignedGreaterThan = v1966 {
                                                                                    if v209.0 == v226.0 {
                                                                                        let v1967 = C::unpack_value_array_2(ctx, v1965);
                                                                                        let v1973 = C::unpack_value_array_2(ctx, v1971);
                                                                                        if v1967.0 == v1973.0 {
                                                                                            if v1967.1 == v1973.1 {
                                                                                                let mut v1357 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                C::inst_data_value_tupled_etor(ctx, v155.1, &mut v1357);
                                                                                                let mut v1357 = v1357.into_context_iter();
                                                                                                while let Some(v1358) = v1357.next(ctx) {
                                                                                                    let v1359 = C::iconst_sextend_etor(ctx, v1358);
                                                                                                    if let Some(v1360) = v1359 {
                                                                                                        if v1360.1 == 0_i64 {
                                                                                                            let v1981 = constructor_ule(ctx, v226.0, v1967.0, v1967.1);
                                                                                                            // Rule at src/opts/spaceship.isle line 163.
                                                                                                            returns.extend(Some(v1981));
                                                                                                            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 v295 = constructor_cmp_true(ctx, v2.0);
                                                    // Rule at src/opts/arithmetic.isle line 417.
                                                    returns.extend(Some(v295));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v155.0 == v171.1 {
                                                    let v295 = constructor_cmp_true(ctx, v2.0);
                                                    // Rule at src/opts/arithmetic.isle line 418.
                                                    returns.extend(Some(v295));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                    &InstructionData::UnaryImm {
                                        opcode: ref v215,
                                        imm: v216,
                                    } => {
                                        if let &Opcode::Iconst = v215 {
                                            let v339 = C::fits_in_64(ctx, v2.0);
                                            if let Some(v340) = v339 {
                                                let v1455 = C::ty_int(ctx, v340);
                                                if let Some(v1456) = v1455 {
                                                    let v217 = C::u64_from_imm64(ctx, v216);
                                                    let v1466 = C::ty_smin(ctx, v166.0);
                                                    let v1467 = C::u64_eq(ctx, v217, v1466);
                                                    if v1467 == true {
                                                        let v1457 = constructor_eq(ctx, v1456, v155.0, v155.1);
                                                        // Rule at src/opts/icmp.isle line 144.
                                                        returns.extend(Some(v1457));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                    let v1468 = C::ty_smax(ctx, v166.0);
                                                    let v1469 = C::u64_eq(ctx, v217, v1468);
                                                    if v1469 == true {
                                                        let v1462 = constructor_iconst_u(ctx, v1456, 0x1_u64);
                                                        let v1463 = C::subsume(ctx, v1462);
                                                        // Rule at src/opts/icmp.isle line 164.
                                                        returns.extend(Some(v1463));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                            if v155.0 == v155.1 {
                                let v344 = C::ty_int(ctx, v2.0);
                                if let Some(v345) = v344 {
                                    let v1400 = constructor_iconst_u(ctx, v345, 0x1_u64);
                                    let v1401 = C::subsume(ctx, v1400);
                                    // Rule at src/opts/icmp.isle line 13.
                                    returns.extend(Some(v1401));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                            let mut v1357 = C::inst_data_value_tupled_etor_returns::default();
                            C::inst_data_value_tupled_etor(ctx, v155.1, &mut v1357);
                            let mut v1357 = v1357.into_context_iter();
                            while let Some(v1358) = v1357.next(ctx) {
                                let v1359 = C::iconst_sextend_etor(ctx, v1358);
                                if let Some(v1360) = v1359 {
                                    if v1360.1 == -1_i64 {
                                        let v1480 = constructor_iconst_s(ctx, v1360.0, 0_i64);
                                        let v1484 = constructor_slt(ctx, v2.0, v155.0, v1480);
                                        // Rule at src/opts/icmp.isle line 204.
                                        returns.extend(Some(v1484));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                            }
                        }
                        &IntCC::UnsignedGreaterThan => {
                            let v339 = C::fits_in_64(ctx, v2.0);
                            if let Some(v340) = v339 {
                                let v1455 = C::ty_int(ctx, v340);
                                if let Some(v1456) = v1455 {
                                    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 v1458 = constructor_ne(ctx, v1456, v155.0, v155.1);
                                                    // Rule at src/opts/icmp.isle line 111.
                                                    returns.extend(Some(v1458));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let v1460 = C::ty_umax(ctx, v166.0);
                                                let v1461 = C::u64_eq(ctx, v217, v1460);
                                                if v1461 == true {
                                                    let v1464 = constructor_iconst_u(ctx, v1456, 0x0_u64);
                                                    let v1465 = C::subsume(ctx, v1464);
                                                    // Rule at src/opts/icmp.isle line 129.
                                                    returns.extend(Some(v1465));
                                                    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 v1711 = constructor_iconst_u(ctx, v340, 0x0_u64);
                                                // Rule at src/opts/selects.isle line 109.
                                                returns.extend(Some(v1711));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            if v155.1 == v205.1 {
                                                let v1711 = constructor_iconst_u(ctx, v340, 0x0_u64);
                                                // Rule at src/opts/selects.isle line 110.
                                                returns.extend(Some(v1711));
                                                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 565.
                                                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 566.
                                                returns.extend(Some(v53));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                }
                            }
                            let v344 = C::ty_int(ctx, v2.0);
                            if let Some(v345) = v344 {
                                if v155.0 == v155.1 {
                                    let v346 = constructor_iconst_u(ctx, v345, 0x0_u64);
                                    let v347 = C::subsume(ctx, v346);
                                    // Rule at src/opts/icmp.isle line 6.
                                    returns.extend(Some(v347));
                                    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 v1528 = constructor_ugt(ctx, v2.0, v205.1, v205.0);
                                            // Rule at src/opts/icmp.isle line 298.
                                            returns.extend(Some(v1528));
                                            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 v295 = constructor_cmp_true(ctx, v2.0);
                                                        // Rule at src/opts/arithmetic.isle line 429.
                                                        returns.extend(Some(v295));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                    if v155.0 == v171.1 {
                                                        let v295 = constructor_cmp_true(ctx, v2.0);
                                                        // Rule at src/opts/arithmetic.isle line 430.
                                                        returns.extend(Some(v295));
                                                        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 v295 = constructor_cmp_true(ctx, v2.0);
                                                        // Rule at src/opts/bitops.isle line 697.
                                                        returns.extend(Some(v295));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                    if v155.0 == v171.1 {
                                                        let v295 = constructor_cmp_true(ctx, v2.0);
                                                        // Rule at src/opts/bitops.isle line 698.
                                                        returns.extend(Some(v295));
                                                        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 v295 = constructor_cmp_true(ctx, v2.0);
                                                    let v1459 = C::subsume(ctx, v295);
                                                    // Rule at src/opts/icmp.isle line 115.
                                                    returns.extend(Some(v1459));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                0x1_u64 => {
                                                    let v298 = constructor_iconst_u(ctx, v166.0, 0x0_u64);
                                                    let v1478 = constructor_ne(ctx, v2.0, v155.0, v298);
                                                    // Rule at src/opts/icmp.isle line 189.
                                                    returns.extend(Some(v1478));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                _ => {}
                                            }
                                            let v339 = C::fits_in_64(ctx, v2.0);
                                            if let Some(v340) = v339 {
                                                let v1455 = C::ty_int(ctx, v340);
                                                if let Some(v1456) = v1455 {
                                                    let v1460 = C::ty_umax(ctx, v166.0);
                                                    let v1461 = C::u64_eq(ctx, v217, v1460);
                                                    if v1461 == true {
                                                        let v1457 = constructor_eq(ctx, v1456, v155.0, v155.1);
                                                        // Rule at src/opts/icmp.isle line 134.
                                                        returns.extend(Some(v1457));
                                                        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 v295 = constructor_cmp_true(ctx, v2.0);
                                                    // Rule at src/opts/arithmetic.isle line 419.
                                                    returns.extend(Some(v295));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v155.1 == v205.1 {
                                                    let v295 = constructor_cmp_true(ctx, v2.0);
                                                    // Rule at src/opts/arithmetic.isle line 420.
                                                    returns.extend(Some(v295));
                                                    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 v295 = constructor_cmp_true(ctx, v2.0);
                                                    // Rule at src/opts/bitops.isle line 703.
                                                    returns.extend(Some(v295));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v155.1 == v205.1 {
                                                    let v295 = constructor_cmp_true(ctx, v2.0);
                                                    // Rule at src/opts/bitops.isle line 704.
                                                    returns.extend(Some(v295));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                            }
                            if v155.0 == v155.1 {
                                let v344 = C::ty_int(ctx, v2.0);
                                if let Some(v345) = v344 {
                                    let v1400 = constructor_iconst_u(ctx, v345, 0x1_u64);
                                    let v1401 = C::subsume(ctx, v1400);
                                    // Rule at src/opts/icmp.isle line 7.
                                    returns.extend(Some(v1401));
                                    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 v339 = C::fits_in_64(ctx, v2.0);
                                            if let Some(v340) = v339 {
                                                let v171 = C::unpack_value_array_2(ctx, v170);
                                                if v155.0 == v171.0 {
                                                    let v1711 = constructor_iconst_u(ctx, v340, 0x0_u64);
                                                    // Rule at src/opts/selects.isle line 111.
                                                    returns.extend(Some(v1711));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v155.0 == v171.1 {
                                                    let v1711 = constructor_iconst_u(ctx, v340, 0x0_u64);
                                                    // Rule at src/opts/selects.isle line 112.
                                                    returns.extend(Some(v1711));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                    &InstructionData::Unary {
                                        opcode: ref v306,
                                        arg: v307,
                                    } => {
                                        if let &Opcode::Bnot = v306 {
                                            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 v304,
                                                    arg: v305,
                                                } = &v159.1 {
                                                    if let &Opcode::Bnot = v304 {
                                                        if v159.0 == v166.0 {
                                                            let v1548 = constructor_ugt(ctx, v2.0, v305, v307);
                                                            // Rule at src/opts/icmp.isle line 305.
                                                            returns.extend(Some(v1548));
                                                            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 v298 = constructor_iconst_u(ctx, v166.0, 0x0_u64);
                                                    let v1479 = constructor_eq(ctx, v2.0, v155.0, v298);
                                                    // Rule at src/opts/icmp.isle line 192.
                                                    returns.extend(Some(v1479));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                _ => {}
                                            }
                                            let v339 = C::fits_in_64(ctx, v2.0);
                                            if let Some(v340) = v339 {
                                                let v1455 = C::ty_int(ctx, v340);
                                                if let Some(v1456) = v1455 {
                                                    let v1460 = C::ty_umax(ctx, v166.0);
                                                    let v1461 = C::u64_eq(ctx, v217, v1460);
                                                    if v1461 == true {
                                                        let v1458 = constructor_ne(ctx, v1456, v155.0, v155.1);
                                                        // Rule at src/opts/icmp.isle line 119.
                                                        returns.extend(Some(v1458));
                                                        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 567.
                                                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 568.
                                                returns.extend(Some(v53));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                }
                            }
                            if v155.0 == v155.1 {
                                let v344 = C::ty_int(ctx, v2.0);
                                if let Some(v345) = v344 {
                                    let v346 = constructor_iconst_u(ctx, v345, 0x0_u64);
                                    let v347 = C::subsume(ctx, v346);
                                    // Rule at src/opts/icmp.isle line 10.
                                    returns.extend(Some(v347));
                                    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 v295 = constructor_cmp_true(ctx, v2.0);
                                                        // Rule at src/opts/arithmetic.isle line 421.
                                                        returns.extend(Some(v295));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                    if v155.0 == v171.1 {
                                                        let v295 = constructor_cmp_true(ctx, v2.0);
                                                        // Rule at src/opts/arithmetic.isle line 422.
                                                        returns.extend(Some(v295));
                                                        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 v295 = constructor_cmp_true(ctx, v2.0);
                                                        // Rule at src/opts/bitops.isle line 705.
                                                        returns.extend(Some(v295));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                    if v155.0 == v171.1 {
                                                        let v295 = constructor_cmp_true(ctx, v2.0);
                                                        // Rule at src/opts/bitops.isle line 706.
                                                        returns.extend(Some(v295));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                    &InstructionData::UnaryImm {
                                        opcode: ref v215,
                                        imm: v216,
                                    } => {
                                        if let &Opcode::Iconst = v215 {
                                            let v339 = C::fits_in_64(ctx, v2.0);
                                            if let Some(v340) = v339 {
                                                let v1455 = C::ty_int(ctx, v340);
                                                if let Some(v1456) = v1455 {
                                                    let v217 = C::u64_from_imm64(ctx, v216);
                                                    if v217 == 0x0_u64 {
                                                        let v1457 = constructor_eq(ctx, v1456, v155.0, v155.1);
                                                        // Rule at src/opts/icmp.isle line 107.
                                                        returns.extend(Some(v1457));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                    let v1460 = C::ty_umax(ctx, v166.0);
                                                    let v1461 = C::u64_eq(ctx, v217, v1460);
                                                    if v1461 == true {
                                                        let v1462 = constructor_iconst_u(ctx, v1456, 0x1_u64);
                                                        let v1463 = C::subsume(ctx, v1462);
                                                        // Rule at src/opts/icmp.isle line 124.
                                                        returns.extend(Some(v1463));
                                                        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 v295 = constructor_cmp_true(ctx, v2.0);
                                                    // Rule at src/opts/arithmetic.isle line 431.
                                                    returns.extend(Some(v295));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v155.1 == v205.1 {
                                                    let v295 = constructor_cmp_true(ctx, v2.0);
                                                    // Rule at src/opts/arithmetic.isle line 432.
                                                    returns.extend(Some(v295));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        &Opcode::Isub => {
                                            let v205 = C::unpack_value_array_2(ctx, v204);
                                            if v155.1 == v205.0 {
                                                let v1529 = constructor_ule(ctx, v2.0, v205.1, v205.0);
                                                // Rule at src/opts/icmp.isle line 299.
                                                returns.extend(Some(v1529));
                                                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 v295 = constructor_cmp_true(ctx, v2.0);
                                                    // Rule at src/opts/bitops.isle line 699.
                                                    returns.extend(Some(v295));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v155.1 == v205.1 {
                                                    let v295 = constructor_cmp_true(ctx, v2.0);
                                                    // Rule at src/opts/bitops.isle line 700.
                                                    returns.extend(Some(v295));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                            }
                            if v155.0 == v155.1 {
                                let v344 = C::ty_int(ctx, v2.0);
                                if let Some(v345) = v344 {
                                    let v1400 = constructor_iconst_u(ctx, v345, 0x1_u64);
                                    let v1401 = C::subsume(ctx, v1400);
                                    // Rule at src/opts/icmp.isle line 11.
                                    returns.extend(Some(v1401));
                                    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 v304,
                                arg: v305,
                            } => {
                                if let &Opcode::Sextend = v304 {
                                    let v1367 = &C::signed_cond_code(ctx, v154);
                                    if let Some(v1368) = v1367 {
                                        let mut v1357 = C::inst_data_value_tupled_etor_returns::default();
                                        C::inst_data_value_tupled_etor(ctx, v155.1, &mut v1357);
                                        let mut v1357 = v1357.into_context_iter();
                                        while let Some(v1358) = v1357.next(ctx) {
                                            let v1359 = C::iconst_sextend_etor(ctx, v1358);
                                            if let Some(v1360) = v1359 {
                                                if v1360.1 == 0_i64 {
                                                    let v1353 = C::value_type(ctx, v305);
                                                    let v1364 = constructor_iconst_s(ctx, v1353, 0_i64);
                                                    let v1369 = constructor_icmp(ctx, v1353, v154, v305, v1364);
                                                    // Rule at src/opts/extends.isle line 43.
                                                    returns.extend(Some(v1369));
                                                    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 v1021 = C::imm64_icmp(ctx, v159.0, v154, v163, v216);
                                                    let v1022 = constructor_iconst(ctx, v2.0, v1021);
                                                    let v1023 = C::subsume(ctx, v1022);
                                                    // Rule at src/opts/cprop.isle line 134.
                                                    returns.extend(Some(v1023));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                    let v1035 = &C::intcc_swap_args(ctx, v154);
                                    let v1036 = constructor_icmp(ctx, v2.0, v1035, v155.1, v155.0);
                                    // Rule at src/opts/cprop.isle line 173.
                                    returns.extend(Some(v1036));
                                    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 v1714,
                                    args: ref v1715,
                                } => {
                                    if let &Opcode::Bor = v1714 {
                                        let v1716 = C::unpack_value_array_2(ctx, v1715);
                                        let mut v1719 = C::inst_data_value_etor_returns::default();
                                        C::inst_data_value_etor(ctx, v1716.1, &mut v1719);
                                        let mut v1719 = v1719.into_context_iter();
                                        while let Some(v1720) = v1719.next(ctx) {
                                            if let &InstructionData::IntCompare {
                                                opcode: ref v1723,
                                                args: ref v1724,
                                                cond: ref v1725,
                                            } = &v1720.1 {
                                                if let &Opcode::Icmp = v1723 {
                                                    if let &IntCC::NotEqual = v1725 {
                                                        if v89.0 == v1720.0 {
                                                            let v1726 = C::unpack_value_array_2(ctx, v1724);
                                                            if v84.1 == v1726.0 {
                                                                if v84.2 == v1726.1 {
                                                                    let v1729 = C::subsume(ctx, v1726.0);
                                                                    // Rule at src/opts/selects.isle line 122.
                                                                    returns.extend(Some(v1729));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                            if v84.1 == v1726.1 {
                                                                if v84.2 == v1726.0 {
                                                                    let v1741 = C::subsume(ctx, v1726.1);
                                                                    // Rule at src/opts/selects.isle line 124.
                                                                    returns.extend(Some(v1741));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        let mut v1730 = C::inst_data_value_etor_returns::default();
                                        C::inst_data_value_etor(ctx, v1716.0, &mut v1730);
                                        let mut v1730 = v1730.into_context_iter();
                                        while let Some(v1731) = v1730.next(ctx) {
                                            if let &InstructionData::IntCompare {
                                                opcode: ref v1734,
                                                args: ref v1735,
                                                cond: ref v1736,
                                            } = &v1731.1 {
                                                if let &Opcode::Icmp = v1734 {
                                                    if let &IntCC::NotEqual = v1736 {
                                                        if v89.0 == v1731.0 {
                                                            let v1737 = C::unpack_value_array_2(ctx, v1735);
                                                            if v84.1 == v1737.0 {
                                                                if v84.2 == v1737.1 {
                                                                    let v1740 = C::subsume(ctx, v1737.0);
                                                                    // Rule at src/opts/selects.isle line 123.
                                                                    returns.extend(Some(v1740));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                            if v84.1 == v1737.1 {
                                                                if v84.2 == v1737.0 {
                                                                    let v1742 = C::subsume(ctx, v1737.1);
                                                                    // Rule at src/opts/selects.isle line 125.
                                                                    returns.extend(Some(v1742));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::IntCompare {
                                    opcode: ref v1485,
                                    args: ref v1486,
                                    cond: ref v1487,
                                } => {
                                    if let &Opcode::Icmp = v1485 {
                                        match v1487 {
                                            &IntCC::Equal => {
                                                let mut v1501 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v84.2, &mut v1501);
                                                let mut v1501 = v1501.into_context_iter();
                                                while let Some(v1502) = v1501.next(ctx) {
                                                    match &v1502.1 {
                                                        &InstructionData::Binary {
                                                            opcode: ref v1743,
                                                            args: ref v1744,
                                                        } => {
                                                            match v1743 {
                                                                &Opcode::Isub => {
                                                                    if v2.0 == v1502.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 v1749,
                                                                                args: ref v1750,
                                                                            } = &v95.1 {
                                                                                if let &Opcode::Isub = v1749 {
                                                                                    if v2.0 == v95.0 {
                                                                                        let v1745 = C::unpack_value_array_2(ctx, v1744);
                                                                                        let v1751 = C::unpack_value_array_2(ctx, v1750);
                                                                                        if v1745.0 == v1751.0 {
                                                                                            let mut v1763 = C::inst_data_value_etor_returns::default();
                                                                                            C::inst_data_value_etor(ctx, v1751.1, &mut v1763);
                                                                                            let mut v1763 = v1763.into_context_iter();
                                                                                            while let Some(v1764) = v1763.next(ctx) {
                                                                                                if let &InstructionData::UnaryImm {
                                                                                                    opcode: ref v1767,
                                                                                                    imm: v1768,
                                                                                                } = &v1764.1 {
                                                                                                    if let &Opcode::Iconst = v1767 {
                                                                                                        if v2.0 == v1764.0 {
                                                                                                            let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                                                            if v1488.0 == v1745.1 {
                                                                                                                let mut v1665 = C::inst_data_value_etor_returns::default();
                                                                                                                C::inst_data_value_etor(ctx, v1488.1, &mut v1665);
                                                                                                                let mut v1665 = v1665.into_context_iter();
                                                                                                                while let Some(v1666) = v1665.next(ctx) {
                                                                                                                    if let &InstructionData::UnaryImm {
                                                                                                                        opcode: ref v1669,
                                                                                                                        imm: v1670,
                                                                                                                    } = &v1666.1 {
                                                                                                                        if let &Opcode::Iconst = v1669 {
                                                                                                                            if v2.0 == v1666.0 {
                                                                                                                                let v1671 = C::u64_from_imm64(ctx, v1670);
                                                                                                                                let v1769 = C::u64_from_imm64(ctx, v1768);
                                                                                                                                if v1671 == v1769 {
                                                                                                                                    let v1770 = constructor_isub(ctx, v2.0, v1751.0, v1488.0);
                                                                                                                                    // Rule at src/opts/selects.isle line 185.
                                                                                                                                    returns.extend(Some(v1770));
                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                            if v1488.1 == v1745.1 {
                                                                                                                let mut v1778 = C::inst_data_value_etor_returns::default();
                                                                                                                C::inst_data_value_etor(ctx, v1488.0, &mut v1778);
                                                                                                                let mut v1778 = v1778.into_context_iter();
                                                                                                                while let Some(v1779) = v1778.next(ctx) {
                                                                                                                    if let &InstructionData::UnaryImm {
                                                                                                                        opcode: ref v1782,
                                                                                                                        imm: v1783,
                                                                                                                    } = &v1779.1 {
                                                                                                                        if let &Opcode::Iconst = v1782 {
                                                                                                                            if v2.0 == v1779.0 {
                                                                                                                                let v1769 = C::u64_from_imm64(ctx, v1768);
                                                                                                                                let v1784 = C::u64_from_imm64(ctx, v1783);
                                                                                                                                if v1769 == v1784 {
                                                                                                                                    let v1785 = constructor_isub(ctx, v2.0, v1751.0, v1488.1);
                                                                                                                                    // Rule at src/opts/selects.isle line 187.
                                                                                                                                    returns.extend(Some(v1785));
                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Band => {
                                                                    if v2.0 == v1502.0 {
                                                                        let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                        if v84.1 == v1488.0 {
                                                                            let v1745 = C::unpack_value_array_2(ctx, v1744);
                                                                            if v84.1 == v1745.0 {
                                                                                if v1488.1 == v1745.1 {
                                                                                    let v1756 = constructor_band(ctx, v2.0, v1488.1, v1488.0);
                                                                                    // Rule at src/opts/selects.isle line 147.
                                                                                    returns.extend(Some(v1756));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                            if v84.1 == v1745.1 {
                                                                                if v1488.1 == v1745.0 {
                                                                                    let v1756 = constructor_band(ctx, v2.0, v1488.1, v1488.0);
                                                                                    // Rule at src/opts/selects.isle line 145.
                                                                                    returns.extend(Some(v1756));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                        if v84.1 == v1488.1 {
                                                                            let v1745 = C::unpack_value_array_2(ctx, v1744);
                                                                            if v84.1 == v1745.0 {
                                                                                if v1488.0 == v1745.1 {
                                                                                    let v1755 = constructor_band(ctx, v2.0, v1488.0, v1488.1);
                                                                                    // Rule at src/opts/selects.isle line 143.
                                                                                    returns.extend(Some(v1755));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                            if v1488.0 == v1745.0 {
                                                                                if v84.1 == v1745.1 {
                                                                                    let v1755 = constructor_band(ctx, v2.0, v1488.0, v1488.1);
                                                                                    // Rule at src/opts/selects.isle line 141.
                                                                                    returns.extend(Some(v1755));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Bor => {
                                                                    if v2.0 == v1502.0 {
                                                                        let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                        if v84.1 == v1488.0 {
                                                                            let v1745 = C::unpack_value_array_2(ctx, v1744);
                                                                            if v84.1 == v1745.0 {
                                                                                if v1488.1 == v1745.1 {
                                                                                    let v1748 = constructor_bor(ctx, v2.0, v1488.0, v1488.1);
                                                                                    // Rule at src/opts/selects.isle line 129.
                                                                                    returns.extend(Some(v1748));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                            if v84.1 == v1745.1 {
                                                                                if v1488.1 == v1745.0 {
                                                                                    let v1748 = constructor_bor(ctx, v2.0, v1488.0, v1488.1);
                                                                                    // Rule at src/opts/selects.isle line 131.
                                                                                    returns.extend(Some(v1748));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                        if v84.1 == v1488.1 {
                                                                            let v1745 = C::unpack_value_array_2(ctx, v1744);
                                                                            if v84.1 == v1745.0 {
                                                                                if v1488.0 == v1745.1 {
                                                                                    let v1754 = constructor_bor(ctx, v2.0, v1488.1, v1488.0);
                                                                                    // Rule at src/opts/selects.isle line 133.
                                                                                    returns.extend(Some(v1754));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                            if v1488.0 == v1745.0 {
                                                                                if v84.1 == v1745.1 {
                                                                                    let v1754 = constructor_bor(ctx, v2.0, v1488.1, v1488.0);
                                                                                    // Rule at src/opts/selects.isle line 135.
                                                                                    returns.extend(Some(v1754));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                        &InstructionData::IntCompare {
                                                            opcode: ref v1505,
                                                            args: ref v1506,
                                                            cond: ref v1507,
                                                        } => {
                                                            if let &Opcode::Icmp = v1505 {
                                                                match v1507 {
                                                                    &IntCC::SignedGreaterThan => {
                                                                        let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                        let v1491 = C::value_type(ctx, v1488.0);
                                                                        if v1491 == I64 {
                                                                            let v1492 = C::value_type(ctx, v1488.1);
                                                                            if v1492 == I64 {
                                                                                if v2.0 == v1502.0 {
                                                                                    let v1508 = C::unpack_value_array_2(ctx, v1506);
                                                                                    if v1488.0 == v1508.0 {
                                                                                        if v1488.1 == v1508.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 v1493,
                                                                                                    args: ref v1494,
                                                                                                    cond: ref v1495,
                                                                                                } = &v95.1 {
                                                                                                    if let &Opcode::Icmp = v1493 {
                                                                                                        if let &IntCC::UnsignedGreaterThan = v1495 {
                                                                                                            let v1496 = C::unpack_value_array_2(ctx, v1494);
                                                                                                            let v1499 = C::value_type(ctx, v1496.0);
                                                                                                            if v1499 == I64 {
                                                                                                                let v1500 = C::value_type(ctx, v1496.1);
                                                                                                                if v1500 == I64 {
                                                                                                                    if v2.0 == v95.0 {
                                                                                                                        let v1511 = constructor_iconcat(ctx, I64, v1496.0, v1488.0);
                                                                                                                        let v1512 = constructor_iconcat(ctx, I64, v1496.1, v1488.1);
                                                                                                                        let v1516 = constructor_sgt(ctx, v2.0, v1511, v1512);
                                                                                                                        // Rule at src/opts/icmp.isle line 268.
                                                                                                                        returns.extend(Some(v1516));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedGreaterThanOrEqual => {
                                                                        let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                        let v1491 = C::value_type(ctx, v1488.0);
                                                                        if v1491 == I64 {
                                                                            let v1492 = C::value_type(ctx, v1488.1);
                                                                            if v1492 == I64 {
                                                                                if v2.0 == v1502.0 {
                                                                                    let v1508 = C::unpack_value_array_2(ctx, v1506);
                                                                                    if v1488.0 == v1508.0 {
                                                                                        if v1488.1 == v1508.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 v1493,
                                                                                                    args: ref v1494,
                                                                                                    cond: ref v1495,
                                                                                                } = &v95.1 {
                                                                                                    if let &Opcode::Icmp = v1493 {
                                                                                                        if let &IntCC::UnsignedGreaterThanOrEqual = v1495 {
                                                                                                            let v1496 = C::unpack_value_array_2(ctx, v1494);
                                                                                                            let v1499 = C::value_type(ctx, v1496.0);
                                                                                                            if v1499 == I64 {
                                                                                                                let v1500 = C::value_type(ctx, v1496.1);
                                                                                                                if v1500 == I64 {
                                                                                                                    if v2.0 == v95.0 {
                                                                                                                        let v1511 = constructor_iconcat(ctx, I64, v1496.0, v1488.0);
                                                                                                                        let v1512 = constructor_iconcat(ctx, I64, v1496.1, v1488.1);
                                                                                                                        let v1514 = constructor_sge(ctx, v2.0, v1511, v1512);
                                                                                                                        // Rule at src/opts/icmp.isle line 258.
                                                                                                                        returns.extend(Some(v1514));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedLessThan => {
                                                                        let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                        let v1491 = C::value_type(ctx, v1488.0);
                                                                        if v1491 == I64 {
                                                                            let v1492 = C::value_type(ctx, v1488.1);
                                                                            if v1492 == I64 {
                                                                                if v2.0 == v1502.0 {
                                                                                    let v1508 = C::unpack_value_array_2(ctx, v1506);
                                                                                    if v1488.0 == v1508.0 {
                                                                                        if v1488.1 == v1508.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 v1493,
                                                                                                    args: ref v1494,
                                                                                                    cond: ref v1495,
                                                                                                } = &v95.1 {
                                                                                                    if let &Opcode::Icmp = v1493 {
                                                                                                        if let &IntCC::UnsignedLessThan = v1495 {
                                                                                                            let v1496 = C::unpack_value_array_2(ctx, v1494);
                                                                                                            let v1499 = C::value_type(ctx, v1496.0);
                                                                                                            if v1499 == I64 {
                                                                                                                let v1500 = C::value_type(ctx, v1496.1);
                                                                                                                if v1500 == I64 {
                                                                                                                    if v2.0 == v95.0 {
                                                                                                                        let v1511 = constructor_iconcat(ctx, I64, v1496.0, v1488.0);
                                                                                                                        let v1512 = constructor_iconcat(ctx, I64, v1496.1, v1488.1);
                                                                                                                        let v1520 = constructor_slt(ctx, v2.0, v1511, v1512);
                                                                                                                        // Rule at src/opts/icmp.isle line 288.
                                                                                                                        returns.extend(Some(v1520));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedLessThanOrEqual => {
                                                                        let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                        let v1491 = C::value_type(ctx, v1488.0);
                                                                        if v1491 == I64 {
                                                                            let v1492 = C::value_type(ctx, v1488.1);
                                                                            if v1492 == I64 {
                                                                                if v2.0 == v1502.0 {
                                                                                    let v1508 = C::unpack_value_array_2(ctx, v1506);
                                                                                    if v1488.0 == v1508.0 {
                                                                                        if v1488.1 == v1508.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 v1493,
                                                                                                    args: ref v1494,
                                                                                                    cond: ref v1495,
                                                                                                } = &v95.1 {
                                                                                                    if let &Opcode::Icmp = v1493 {
                                                                                                        if let &IntCC::UnsignedLessThanOrEqual = v1495 {
                                                                                                            let v1496 = C::unpack_value_array_2(ctx, v1494);
                                                                                                            let v1499 = C::value_type(ctx, v1496.0);
                                                                                                            if v1499 == I64 {
                                                                                                                let v1500 = C::value_type(ctx, v1496.1);
                                                                                                                if v1500 == I64 {
                                                                                                                    if v2.0 == v95.0 {
                                                                                                                        let v1511 = constructor_iconcat(ctx, I64, v1496.0, v1488.0);
                                                                                                                        let v1512 = constructor_iconcat(ctx, I64, v1496.1, v1488.1);
                                                                                                                        let v1518 = constructor_sle(ctx, v2.0, v1511, v1512);
                                                                                                                        // Rule at src/opts/icmp.isle line 278.
                                                                                                                        returns.extend(Some(v1518));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedGreaterThan => {
                                                                        let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                        let v1491 = C::value_type(ctx, v1488.0);
                                                                        if v1491 == I64 {
                                                                            let v1492 = C::value_type(ctx, v1488.1);
                                                                            if v1492 == I64 {
                                                                                if v2.0 == v1502.0 {
                                                                                    let v1508 = C::unpack_value_array_2(ctx, v1506);
                                                                                    if v1488.0 == v1508.0 {
                                                                                        if v1488.1 == v1508.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 v1493,
                                                                                                    args: ref v1494,
                                                                                                    cond: ref v1495,
                                                                                                } = &v95.1 {
                                                                                                    if let &Opcode::Icmp = v1493 {
                                                                                                        if let &IntCC::UnsignedGreaterThan = v1495 {
                                                                                                            let v1496 = C::unpack_value_array_2(ctx, v1494);
                                                                                                            let v1499 = C::value_type(ctx, v1496.0);
                                                                                                            if v1499 == I64 {
                                                                                                                let v1500 = C::value_type(ctx, v1496.1);
                                                                                                                if v1500 == I64 {
                                                                                                                    if v2.0 == v95.0 {
                                                                                                                        let v1511 = constructor_iconcat(ctx, I64, v1496.0, v1488.0);
                                                                                                                        let v1512 = constructor_iconcat(ctx, I64, v1496.1, v1488.1);
                                                                                                                        let v1515 = constructor_ugt(ctx, v2.0, v1511, v1512);
                                                                                                                        // Rule at src/opts/icmp.isle line 263.
                                                                                                                        returns.extend(Some(v1515));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedGreaterThanOrEqual => {
                                                                        let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                        let v1491 = C::value_type(ctx, v1488.0);
                                                                        if v1491 == I64 {
                                                                            let v1492 = C::value_type(ctx, v1488.1);
                                                                            if v1492 == I64 {
                                                                                if v2.0 == v1502.0 {
                                                                                    let v1508 = C::unpack_value_array_2(ctx, v1506);
                                                                                    if v1488.0 == v1508.0 {
                                                                                        if v1488.1 == v1508.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 v1493,
                                                                                                    args: ref v1494,
                                                                                                    cond: ref v1495,
                                                                                                } = &v95.1 {
                                                                                                    if let &Opcode::Icmp = v1493 {
                                                                                                        if let &IntCC::UnsignedGreaterThanOrEqual = v1495 {
                                                                                                            let v1496 = C::unpack_value_array_2(ctx, v1494);
                                                                                                            let v1499 = C::value_type(ctx, v1496.0);
                                                                                                            if v1499 == I64 {
                                                                                                                let v1500 = C::value_type(ctx, v1496.1);
                                                                                                                if v1500 == I64 {
                                                                                                                    if v2.0 == v95.0 {
                                                                                                                        let v1511 = constructor_iconcat(ctx, I64, v1496.0, v1488.0);
                                                                                                                        let v1512 = constructor_iconcat(ctx, I64, v1496.1, v1488.1);
                                                                                                                        let v1513 = constructor_uge(ctx, v2.0, v1511, v1512);
                                                                                                                        // Rule at src/opts/icmp.isle line 253.
                                                                                                                        returns.extend(Some(v1513));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                        let v1491 = C::value_type(ctx, v1488.0);
                                                                        if v1491 == I64 {
                                                                            let v1492 = C::value_type(ctx, v1488.1);
                                                                            if v1492 == I64 {
                                                                                if v2.0 == v1502.0 {
                                                                                    let v1508 = C::unpack_value_array_2(ctx, v1506);
                                                                                    if v1488.0 == v1508.0 {
                                                                                        if v1488.1 == v1508.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 v1493,
                                                                                                    args: ref v1494,
                                                                                                    cond: ref v1495,
                                                                                                } = &v95.1 {
                                                                                                    if let &Opcode::Icmp = v1493 {
                                                                                                        if let &IntCC::UnsignedLessThan = v1495 {
                                                                                                            let v1496 = C::unpack_value_array_2(ctx, v1494);
                                                                                                            let v1499 = C::value_type(ctx, v1496.0);
                                                                                                            if v1499 == I64 {
                                                                                                                let v1500 = C::value_type(ctx, v1496.1);
                                                                                                                if v1500 == I64 {
                                                                                                                    if v2.0 == v95.0 {
                                                                                                                        let v1511 = constructor_iconcat(ctx, I64, v1496.0, v1488.0);
                                                                                                                        let v1512 = constructor_iconcat(ctx, I64, v1496.1, v1488.1);
                                                                                                                        let v1519 = constructor_ult(ctx, v2.0, v1511, v1512);
                                                                                                                        // Rule at src/opts/icmp.isle line 283.
                                                                                                                        returns.extend(Some(v1519));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThanOrEqual => {
                                                                        let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                        let v1491 = C::value_type(ctx, v1488.0);
                                                                        if v1491 == I64 {
                                                                            let v1492 = C::value_type(ctx, v1488.1);
                                                                            if v1492 == I64 {
                                                                                if v2.0 == v1502.0 {
                                                                                    let v1508 = C::unpack_value_array_2(ctx, v1506);
                                                                                    if v1488.0 == v1508.0 {
                                                                                        if v1488.1 == v1508.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 v1493,
                                                                                                    args: ref v1494,
                                                                                                    cond: ref v1495,
                                                                                                } = &v95.1 {
                                                                                                    if let &Opcode::Icmp = v1493 {
                                                                                                        if let &IntCC::UnsignedLessThanOrEqual = v1495 {
                                                                                                            let v1496 = C::unpack_value_array_2(ctx, v1494);
                                                                                                            let v1499 = C::value_type(ctx, v1496.0);
                                                                                                            if v1499 == I64 {
                                                                                                                let v1500 = C::value_type(ctx, v1496.1);
                                                                                                                if v1500 == I64 {
                                                                                                                    if v2.0 == v95.0 {
                                                                                                                        let v1511 = constructor_iconcat(ctx, I64, v1496.0, v1488.0);
                                                                                                                        let v1512 = constructor_iconcat(ctx, I64, v1496.1, v1488.1);
                                                                                                                        let v1517 = constructor_ule(ctx, v2.0, v1511, v1512);
                                                                                                                        // Rule at src/opts/icmp.isle line 273.
                                                                                                                        returns.extend(Some(v1517));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::Ternary {
                                                            opcode: ref v1697,
                                                            args: ref v1698,
                                                        } => {
                                                            if let &Opcode::Select = v1697 {
                                                                if v2.0 == v1502.0 {
                                                                    let mut v1629 = C::inst_data_value_tupled_etor_returns::default();
                                                                    C::inst_data_value_tupled_etor(ctx, v84.1, &mut v1629);
                                                                    let mut v1629 = v1629.into_context_iter();
                                                                    while let Some(v1630) = v1629.next(ctx) {
                                                                        let v1631 = C::iconst_sextend_etor(ctx, v1630);
                                                                        if let Some(v1632) = v1631 {
                                                                            if v1632.1 == 0_i64 {
                                                                                if v2.0 == v1632.0 {
                                                                                    let v1699 = C::unpack_value_array_3(ctx, v1698);
                                                                                    let mut v1930 = C::inst_data_value_etor_returns::default();
                                                                                    C::inst_data_value_etor(ctx, v1699.0, &mut v1930);
                                                                                    let mut v1930 = v1930.into_context_iter();
                                                                                    while let Some(v1931) = v1930.next(ctx) {
                                                                                        if let &InstructionData::IntCompare {
                                                                                            opcode: ref v1934,
                                                                                            args: ref v1935,
                                                                                            cond: ref v1936,
                                                                                        } = &v1931.1 {
                                                                                            if let &Opcode::Icmp = v1934 {
                                                                                                match v1936 {
                                                                                                    &IntCC::SignedGreaterThan => {
                                                                                                        if v89.0 == v1931.0 {
                                                                                                            let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                                                            let v1937 = C::unpack_value_array_2(ctx, v1935);
                                                                                                            if v1488.0 == v1937.0 {
                                                                                                                if v1488.1 == v1937.1 {
                                                                                                                    let mut v1940 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1699.1, &mut v1940);
                                                                                                                    let mut v1940 = v1940.into_context_iter();
                                                                                                                    while let Some(v1941) = v1940.next(ctx) {
                                                                                                                        let v1942 = C::iconst_sextend_etor(ctx, v1941);
                                                                                                                        if let Some(v1943) = v1942 {
                                                                                                                            if v1943.1 == 1_i64 {
                                                                                                                                if v2.0 == v1943.0 {
                                                                                                                                    let mut v1946 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1699.2, &mut v1946);
                                                                                                                                    let mut v1946 = v1946.into_context_iter();
                                                                                                                                    while let Some(v1947) = v1946.next(ctx) {
                                                                                                                                        let v1948 = C::iconst_sextend_etor(ctx, v1947);
                                                                                                                                        if let Some(v1949) = v1948 {
                                                                                                                                            if v1949.1 == -1_i64 {
                                                                                                                                                if v2.0 == v1949.0 {
                                                                                                                                                    let v1962 = constructor_spaceship_s(ctx, v89.0, v1488.0, v1488.1);
                                                                                                                                                    let v1963 = constructor_sextend_maybe(ctx, v2.0, v1962);
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 103.
                                                                                                                                                    returns.extend(Some(v1963));
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    &IntCC::SignedGreaterThanOrEqual => {
                                                                                                        if v89.0 == v1931.0 {
                                                                                                            let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                                                            let v1937 = C::unpack_value_array_2(ctx, v1935);
                                                                                                            if v1488.0 == v1937.0 {
                                                                                                                if v1488.1 == v1937.1 {
                                                                                                                    let mut v1940 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1699.1, &mut v1940);
                                                                                                                    let mut v1940 = v1940.into_context_iter();
                                                                                                                    while let Some(v1941) = v1940.next(ctx) {
                                                                                                                        let v1942 = C::iconst_sextend_etor(ctx, v1941);
                                                                                                                        if let Some(v1943) = v1942 {
                                                                                                                            if v1943.1 == 1_i64 {
                                                                                                                                if v2.0 == v1943.0 {
                                                                                                                                    let mut v1946 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1699.2, &mut v1946);
                                                                                                                                    let mut v1946 = v1946.into_context_iter();
                                                                                                                                    while let Some(v1947) = v1946.next(ctx) {
                                                                                                                                        let v1948 = C::iconst_sextend_etor(ctx, v1947);
                                                                                                                                        if let Some(v1949) = v1948 {
                                                                                                                                            if v1949.1 == -1_i64 {
                                                                                                                                                if v2.0 == v1949.0 {
                                                                                                                                                    let v1962 = constructor_spaceship_s(ctx, v89.0, v1488.0, v1488.1);
                                                                                                                                                    let v1963 = constructor_sextend_maybe(ctx, v2.0, v1962);
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 110.
                                                                                                                                                    returns.extend(Some(v1963));
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    &IntCC::SignedLessThan => {
                                                                                                        if v89.0 == v1931.0 {
                                                                                                            let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                                                            let v1937 = C::unpack_value_array_2(ctx, v1935);
                                                                                                            if v1488.0 == v1937.0 {
                                                                                                                if v1488.1 == v1937.1 {
                                                                                                                    let mut v1940 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1699.1, &mut v1940);
                                                                                                                    let mut v1940 = v1940.into_context_iter();
                                                                                                                    while let Some(v1941) = v1940.next(ctx) {
                                                                                                                        let v1942 = C::iconst_sextend_etor(ctx, v1941);
                                                                                                                        if let Some(v1943) = v1942 {
                                                                                                                            if v1943.1 == -1_i64 {
                                                                                                                                if v2.0 == v1943.0 {
                                                                                                                                    let mut v1946 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1699.2, &mut v1946);
                                                                                                                                    let mut v1946 = v1946.into_context_iter();
                                                                                                                                    while let Some(v1947) = v1946.next(ctx) {
                                                                                                                                        let v1948 = C::iconst_sextend_etor(ctx, v1947);
                                                                                                                                        if let Some(v1949) = v1948 {
                                                                                                                                            if v1949.1 == 1_i64 {
                                                                                                                                                if v2.0 == v1949.0 {
                                                                                                                                                    let v1962 = constructor_spaceship_s(ctx, v89.0, v1488.0, v1488.1);
                                                                                                                                                    let v1963 = constructor_sextend_maybe(ctx, v2.0, v1962);
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 89.
                                                                                                                                                    returns.extend(Some(v1963));
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    &IntCC::SignedLessThanOrEqual => {
                                                                                                        if v89.0 == v1931.0 {
                                                                                                            let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                                                            let v1937 = C::unpack_value_array_2(ctx, v1935);
                                                                                                            if v1488.0 == v1937.0 {
                                                                                                                if v1488.1 == v1937.1 {
                                                                                                                    let mut v1940 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1699.1, &mut v1940);
                                                                                                                    let mut v1940 = v1940.into_context_iter();
                                                                                                                    while let Some(v1941) = v1940.next(ctx) {
                                                                                                                        let v1942 = C::iconst_sextend_etor(ctx, v1941);
                                                                                                                        if let Some(v1943) = v1942 {
                                                                                                                            if v1943.1 == -1_i64 {
                                                                                                                                if v2.0 == v1943.0 {
                                                                                                                                    let mut v1946 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1699.2, &mut v1946);
                                                                                                                                    let mut v1946 = v1946.into_context_iter();
                                                                                                                                    while let Some(v1947) = v1946.next(ctx) {
                                                                                                                                        let v1948 = C::iconst_sextend_etor(ctx, v1947);
                                                                                                                                        if let Some(v1949) = v1948 {
                                                                                                                                            if v1949.1 == 1_i64 {
                                                                                                                                                if v2.0 == v1949.0 {
                                                                                                                                                    let v1962 = constructor_spaceship_s(ctx, v89.0, v1488.0, v1488.1);
                                                                                                                                                    let v1963 = constructor_sextend_maybe(ctx, v2.0, v1962);
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 96.
                                                                                                                                                    returns.extend(Some(v1963));
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    &IntCC::UnsignedGreaterThan => {
                                                                                                        if v89.0 == v1931.0 {
                                                                                                            let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                                                            let v1937 = C::unpack_value_array_2(ctx, v1935);
                                                                                                            if v1488.0 == v1937.0 {
                                                                                                                if v1488.1 == v1937.1 {
                                                                                                                    let mut v1940 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1699.1, &mut v1940);
                                                                                                                    let mut v1940 = v1940.into_context_iter();
                                                                                                                    while let Some(v1941) = v1940.next(ctx) {
                                                                                                                        let v1942 = C::iconst_sextend_etor(ctx, v1941);
                                                                                                                        if let Some(v1943) = v1942 {
                                                                                                                            if v1943.1 == 1_i64 {
                                                                                                                                if v2.0 == v1943.0 {
                                                                                                                                    let mut v1946 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1699.2, &mut v1946);
                                                                                                                                    let mut v1946 = v1946.into_context_iter();
                                                                                                                                    while let Some(v1947) = v1946.next(ctx) {
                                                                                                                                        let v1948 = C::iconst_sextend_etor(ctx, v1947);
                                                                                                                                        if let Some(v1949) = v1948 {
                                                                                                                                            if v1949.1 == -1_i64 {
                                                                                                                                                if v2.0 == v1949.0 {
                                                                                                                                                    let v1928 = constructor_spaceship_u(ctx, v89.0, v1488.0, v1488.1);
                                                                                                                                                    let v1929 = constructor_sextend_maybe(ctx, v2.0, v1928);
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 38.
                                                                                                                                                    returns.extend(Some(v1929));
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    &IntCC::UnsignedGreaterThanOrEqual => {
                                                                                                        if v89.0 == v1931.0 {
                                                                                                            let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                                                            let v1937 = C::unpack_value_array_2(ctx, v1935);
                                                                                                            if v1488.0 == v1937.0 {
                                                                                                                if v1488.1 == v1937.1 {
                                                                                                                    let mut v1940 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1699.1, &mut v1940);
                                                                                                                    let mut v1940 = v1940.into_context_iter();
                                                                                                                    while let Some(v1941) = v1940.next(ctx) {
                                                                                                                        let v1942 = C::iconst_sextend_etor(ctx, v1941);
                                                                                                                        if let Some(v1943) = v1942 {
                                                                                                                            if v1943.1 == 1_i64 {
                                                                                                                                if v2.0 == v1943.0 {
                                                                                                                                    let mut v1946 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1699.2, &mut v1946);
                                                                                                                                    let mut v1946 = v1946.into_context_iter();
                                                                                                                                    while let Some(v1947) = v1946.next(ctx) {
                                                                                                                                        let v1948 = C::iconst_sextend_etor(ctx, v1947);
                                                                                                                                        if let Some(v1949) = v1948 {
                                                                                                                                            if v1949.1 == -1_i64 {
                                                                                                                                                if v2.0 == v1949.0 {
                                                                                                                                                    let v1928 = constructor_spaceship_u(ctx, v89.0, v1488.0, v1488.1);
                                                                                                                                                    let v1929 = constructor_sextend_maybe(ctx, v2.0, v1928);
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 45.
                                                                                                                                                    returns.extend(Some(v1929));
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    &IntCC::UnsignedLessThan => {
                                                                                                        if v89.0 == v1931.0 {
                                                                                                            let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                                                            let v1937 = C::unpack_value_array_2(ctx, v1935);
                                                                                                            if v1488.0 == v1937.0 {
                                                                                                                if v1488.1 == v1937.1 {
                                                                                                                    let mut v1940 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1699.1, &mut v1940);
                                                                                                                    let mut v1940 = v1940.into_context_iter();
                                                                                                                    while let Some(v1941) = v1940.next(ctx) {
                                                                                                                        let v1942 = C::iconst_sextend_etor(ctx, v1941);
                                                                                                                        if let Some(v1943) = v1942 {
                                                                                                                            if v1943.1 == -1_i64 {
                                                                                                                                if v2.0 == v1943.0 {
                                                                                                                                    let mut v1946 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1699.2, &mut v1946);
                                                                                                                                    let mut v1946 = v1946.into_context_iter();
                                                                                                                                    while let Some(v1947) = v1946.next(ctx) {
                                                                                                                                        let v1948 = C::iconst_sextend_etor(ctx, v1947);
                                                                                                                                        if let Some(v1949) = v1948 {
                                                                                                                                            if v1949.1 == 1_i64 {
                                                                                                                                                if v2.0 == v1949.0 {
                                                                                                                                                    let v1928 = constructor_spaceship_u(ctx, v89.0, v1488.0, v1488.1);
                                                                                                                                                    let v1929 = constructor_sextend_maybe(ctx, v2.0, v1928);
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 24.
                                                                                                                                                    returns.extend(Some(v1929));
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    &IntCC::UnsignedLessThanOrEqual => {
                                                                                                        if v89.0 == v1931.0 {
                                                                                                            let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                                                            let v1937 = C::unpack_value_array_2(ctx, v1935);
                                                                                                            if v1488.0 == v1937.0 {
                                                                                                                if v1488.1 == v1937.1 {
                                                                                                                    let mut v1940 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1699.1, &mut v1940);
                                                                                                                    let mut v1940 = v1940.into_context_iter();
                                                                                                                    while let Some(v1941) = v1940.next(ctx) {
                                                                                                                        let v1942 = C::iconst_sextend_etor(ctx, v1941);
                                                                                                                        if let Some(v1943) = v1942 {
                                                                                                                            if v1943.1 == -1_i64 {
                                                                                                                                if v2.0 == v1943.0 {
                                                                                                                                    let mut v1946 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1699.2, &mut v1946);
                                                                                                                                    let mut v1946 = v1946.into_context_iter();
                                                                                                                                    while let Some(v1947) = v1946.next(ctx) {
                                                                                                                                        let v1948 = C::iconst_sextend_etor(ctx, v1947);
                                                                                                                                        if let Some(v1949) = v1948 {
                                                                                                                                            if v1949.1 == 1_i64 {
                                                                                                                                                if v2.0 == v1949.0 {
                                                                                                                                                    let v1928 = constructor_spaceship_u(ctx, v89.0, v1488.0, v1488.1);
                                                                                                                                                    let v1929 = constructor_sextend_maybe(ctx, v2.0, v1928);
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 31.
                                                                                                                                                    returns.extend(Some(v1929));
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    _ => {}
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                if v84.1 == v1488.0 {
                                                    if v84.2 == v1488.1 {
                                                        let v1712 = C::subsume(ctx, v1488.1);
                                                        // Rule at src/opts/selects.isle line 116.
                                                        returns.extend(Some(v1712));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v84.2 == v1488.0 {
                                                    if v84.1 == v1488.1 {
                                                        let v1713 = C::subsume(ctx, v1488.0);
                                                        // Rule at src/opts/selects.isle line 118.
                                                        returns.extend(Some(v1713));
                                                        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 v1749,
                                                        args: ref v1750,
                                                    } = &v95.1 {
                                                        match v1749 {
                                                            &Opcode::Isub => {
                                                                if v2.0 == v95.0 {
                                                                    let mut v1501 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v84.2, &mut v1501);
                                                                    let mut v1501 = v1501.into_context_iter();
                                                                    while let Some(v1502) = v1501.next(ctx) {
                                                                        if let &InstructionData::Binary {
                                                                            opcode: ref v1743,
                                                                            args: ref v1744,
                                                                        } = &v1502.1 {
                                                                            if let &Opcode::Isub = v1743 {
                                                                                if v2.0 == v1502.0 {
                                                                                    let v1745 = C::unpack_value_array_2(ctx, v1744);
                                                                                    let v1751 = C::unpack_value_array_2(ctx, v1750);
                                                                                    if v1745.0 == v1751.0 {
                                                                                        let mut v1771 = C::inst_data_value_etor_returns::default();
                                                                                        C::inst_data_value_etor(ctx, v1745.1, &mut v1771);
                                                                                        let mut v1771 = v1771.into_context_iter();
                                                                                        while let Some(v1772) = v1771.next(ctx) {
                                                                                            if let &InstructionData::UnaryImm {
                                                                                                opcode: ref v1775,
                                                                                                imm: v1776,
                                                                                            } = &v1772.1 {
                                                                                                if let &Opcode::Iconst = v1775 {
                                                                                                    if v2.0 == v1772.0 {
                                                                                                        let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                                                        if v1488.0 == v1751.1 {
                                                                                                            let mut v1665 = C::inst_data_value_etor_returns::default();
                                                                                                            C::inst_data_value_etor(ctx, v1488.1, &mut v1665);
                                                                                                            let mut v1665 = v1665.into_context_iter();
                                                                                                            while let Some(v1666) = v1665.next(ctx) {
                                                                                                                if let &InstructionData::UnaryImm {
                                                                                                                    opcode: ref v1669,
                                                                                                                    imm: v1670,
                                                                                                                } = &v1666.1 {
                                                                                                                    if let &Opcode::Iconst = v1669 {
                                                                                                                        if v2.0 == v1666.0 {
                                                                                                                            let v1671 = C::u64_from_imm64(ctx, v1670);
                                                                                                                            let v1777 = C::u64_from_imm64(ctx, v1776);
                                                                                                                            if v1671 == v1777 {
                                                                                                                                let v1770 = constructor_isub(ctx, v2.0, v1751.0, v1488.0);
                                                                                                                                // Rule at src/opts/selects.isle line 186.
                                                                                                                                returns.extend(Some(v1770));
                                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                        if v1488.1 == v1751.1 {
                                                                                                            let mut v1778 = C::inst_data_value_etor_returns::default();
                                                                                                            C::inst_data_value_etor(ctx, v1488.0, &mut v1778);
                                                                                                            let mut v1778 = v1778.into_context_iter();
                                                                                                            while let Some(v1779) = v1778.next(ctx) {
                                                                                                                if let &InstructionData::UnaryImm {
                                                                                                                    opcode: ref v1782,
                                                                                                                    imm: v1783,
                                                                                                                } = &v1779.1 {
                                                                                                                    if let &Opcode::Iconst = v1782 {
                                                                                                                        if v2.0 == v1779.0 {
                                                                                                                            let v1777 = C::u64_from_imm64(ctx, v1776);
                                                                                                                            let v1784 = C::u64_from_imm64(ctx, v1783);
                                                                                                                            if v1777 == v1784 {
                                                                                                                                let v1785 = constructor_isub(ctx, v2.0, v1751.0, v1488.1);
                                                                                                                                // Rule at src/opts/selects.isle line 188.
                                                                                                                                returns.extend(Some(v1785));
                                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Band => {
                                                                if v2.0 == v95.0 {
                                                                    let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                    if v84.2 == v1488.0 {
                                                                        let v1751 = C::unpack_value_array_2(ctx, v1750);
                                                                        if v84.2 == v1751.0 {
                                                                            if v1488.1 == v1751.1 {
                                                                                let v1756 = constructor_band(ctx, v2.0, v1488.1, v1488.0);
                                                                                // Rule at src/opts/selects.isle line 146.
                                                                                returns.extend(Some(v1756));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                        if v84.2 == v1751.1 {
                                                                            if v1488.1 == v1751.0 {
                                                                                let v1756 = constructor_band(ctx, v2.0, v1488.1, v1488.0);
                                                                                // Rule at src/opts/selects.isle line 144.
                                                                                returns.extend(Some(v1756));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                    if v84.2 == v1488.1 {
                                                                        let v1751 = C::unpack_value_array_2(ctx, v1750);
                                                                        if v84.2 == v1751.0 {
                                                                            if v1488.0 == v1751.1 {
                                                                                let v1755 = constructor_band(ctx, v2.0, v1488.0, v1488.1);
                                                                                // Rule at src/opts/selects.isle line 142.
                                                                                returns.extend(Some(v1755));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                        if v1488.0 == v1751.0 {
                                                                            if v84.2 == v1751.1 {
                                                                                let v1755 = constructor_band(ctx, v2.0, v1488.0, v1488.1);
                                                                                // Rule at src/opts/selects.isle line 140.
                                                                                returns.extend(Some(v1755));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Bor => {
                                                                if v2.0 == v95.0 {
                                                                    let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                    if v84.2 == v1488.0 {
                                                                        let v1751 = C::unpack_value_array_2(ctx, v1750);
                                                                        if v84.2 == v1751.0 {
                                                                            if v1488.1 == v1751.1 {
                                                                                let v1748 = constructor_bor(ctx, v2.0, v1488.0, v1488.1);
                                                                                // Rule at src/opts/selects.isle line 130.
                                                                                returns.extend(Some(v1748));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                        if v84.2 == v1751.1 {
                                                                            if v1488.1 == v1751.0 {
                                                                                let v1748 = constructor_bor(ctx, v2.0, v1488.0, v1488.1);
                                                                                // Rule at src/opts/selects.isle line 132.
                                                                                returns.extend(Some(v1748));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                    if v84.2 == v1488.1 {
                                                                        let v1751 = C::unpack_value_array_2(ctx, v1750);
                                                                        if v84.2 == v1751.0 {
                                                                            if v1488.0 == v1751.1 {
                                                                                let v1754 = constructor_bor(ctx, v2.0, v1488.1, v1488.0);
                                                                                // Rule at src/opts/selects.isle line 134.
                                                                                returns.extend(Some(v1754));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                        if v1488.0 == v1751.0 {
                                                                            if v84.2 == v1751.1 {
                                                                                let v1754 = constructor_bor(ctx, v2.0, v1488.1, v1488.0);
                                                                                // Rule at src/opts/selects.isle line 136.
                                                                                returns.extend(Some(v1754));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                    }
                                                }
                                                let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                if v84.1 == v1488.0 {
                                                    if v84.2 == v1488.1 {
                                                        let v1713 = C::subsume(ctx, v1488.0);
                                                        // Rule at src/opts/selects.isle line 119.
                                                        returns.extend(Some(v1713));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v84.1 == v1488.1 {
                                                    if v84.2 == v1488.0 {
                                                        let v1712 = C::subsume(ctx, v1488.1);
                                                        // Rule at src/opts/selects.isle line 117.
                                                        returns.extend(Some(v1712));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::SignedGreaterThan => {
                                                let mut v1501 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v84.2, &mut v1501);
                                                let mut v1501 = v1501.into_context_iter();
                                                while let Some(v1502) = v1501.next(ctx) {
                                                    match &v1502.1 {
                                                        &InstructionData::IntCompare {
                                                            opcode: ref v1505,
                                                            args: ref v1506,
                                                            cond: ref v1507,
                                                        } => {
                                                            if let &Opcode::Icmp = v1505 {
                                                                match v1507 {
                                                                    &IntCC::SignedGreaterThan => {
                                                                        if v2.0 == v1502.0 {
                                                                            let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                            let v1508 = C::unpack_value_array_2(ctx, v1506);
                                                                            if v1488.0 == v1508.1 {
                                                                                if v1488.1 == v1508.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 v1617,
                                                                                            imm: v1618,
                                                                                        } = &v95.1 {
                                                                                            if let &Opcode::Iconst = v1617 {
                                                                                                let v1619 = C::u64_from_imm64(ctx, v1618);
                                                                                                if v1619 == 0x1_u64 {
                                                                                                    if v2.0 == v95.0 {
                                                                                                        let v1760 = constructor_ne(ctx, v2.0, v1488.1, v1488.0);
                                                                                                        // Rule at src/opts/selects.isle line 164.
                                                                                                        returns.extend(Some(v1760));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedLessThan => {
                                                                        if v2.0 == v1502.0 {
                                                                            let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                            let v1508 = C::unpack_value_array_2(ctx, v1506);
                                                                            if v1488.0 == v1508.0 {
                                                                                if v1488.1 == v1508.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 v1617,
                                                                                            imm: v1618,
                                                                                        } = &v95.1 {
                                                                                            if let &Opcode::Iconst = v1617 {
                                                                                                let v1619 = C::u64_from_imm64(ctx, v1618);
                                                                                                if v1619 == 0x1_u64 {
                                                                                                    if v2.0 == v95.0 {
                                                                                                        let v1760 = constructor_ne(ctx, v2.0, v1488.1, v1488.0);
                                                                                                        // Rule at src/opts/selects.isle line 168.
                                                                                                        returns.extend(Some(v1760));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v1659,
                                                            arg: v1660,
                                                        } => {
                                                            match v1659 {
                                                                &Opcode::Ineg => {
                                                                    if v89.0 == v1502.0 {
                                                                        let mut v1629 = C::inst_data_value_tupled_etor_returns::default();
                                                                        C::inst_data_value_tupled_etor(ctx, v84.1, &mut v1629);
                                                                        let mut v1629 = v1629.into_context_iter();
                                                                        while let Some(v1630) = v1629.next(ctx) {
                                                                            let v1631 = C::iconst_sextend_etor(ctx, v1630);
                                                                            if let Some(v1632) = v1631 {
                                                                                if v1632.1 == 1_i64 {
                                                                                    if v2.0 == v1632.0 {
                                                                                        let mut v1952 = C::inst_data_value_etor_returns::default();
                                                                                        C::inst_data_value_etor(ctx, v1660, &mut v1952);
                                                                                        let mut v1952 = v1952.into_context_iter();
                                                                                        while let Some(v1953) = v1952.next(ctx) {
                                                                                            if let &InstructionData::IntCompare {
                                                                                                opcode: ref v1956,
                                                                                                args: ref v1957,
                                                                                                cond: ref v1958,
                                                                                            } = &v1953.1 {
                                                                                                if let &Opcode::Icmp = v1956 {
                                                                                                    match v1958 {
                                                                                                        &IntCC::NotEqual => {
                                                                                                            if v89.0 == v1953.0 {
                                                                                                                let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                                                                let v1959 = C::unpack_value_array_2(ctx, v1957);
                                                                                                                if v1488.0 == v1959.0 {
                                                                                                                    if v1488.1 == v1959.1 {
                                                                                                                        let v1962 = constructor_spaceship_s(ctx, v89.0, v1488.0, v1488.1);
                                                                                                                        let v1963 = constructor_sextend_maybe(ctx, v2.0, v1962);
                                                                                                                        // Rule at src/opts/spaceship.isle line 129.
                                                                                                                        returns.extend(Some(v1963));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                        &IntCC::SignedLessThan => {
                                                                                                            if v89.0 == v1953.0 {
                                                                                                                let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                                                                let v1959 = C::unpack_value_array_2(ctx, v1957);
                                                                                                                if v1488.0 == v1959.0 {
                                                                                                                    if v1488.1 == v1959.1 {
                                                                                                                        let v1962 = constructor_spaceship_s(ctx, v89.0, v1488.0, v1488.1);
                                                                                                                        let v1963 = constructor_sextend_maybe(ctx, v2.0, v1962);
                                                                                                                        // Rule at src/opts/spaceship.isle line 119.
                                                                                                                        returns.extend(Some(v1963));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                        _ => {}
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    if v2.0 == v1502.0 {
                                                                        let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                        if v84.1 == v1488.0 {
                                                                            if v84.1 == v1660 {
                                                                                let mut v1665 = C::inst_data_value_etor_returns::default();
                                                                                C::inst_data_value_etor(ctx, v1488.1, &mut v1665);
                                                                                let mut v1665 = v1665.into_context_iter();
                                                                                while let Some(v1666) = v1665.next(ctx) {
                                                                                    if let &InstructionData::UnaryImm {
                                                                                        opcode: ref v1669,
                                                                                        imm: v1670,
                                                                                    } = &v1666.1 {
                                                                                        if let &Opcode::Iconst = v1669 {
                                                                                            let v1671 = C::u64_from_imm64(ctx, v1670);
                                                                                            if v1671 == 0x0_u64 {
                                                                                                if v2.0 == v1666.0 {
                                                                                                    let v1672 = constructor_iabs(ctx, v2.0, v1488.0);
                                                                                                    let v1673 = C::subsume(ctx, v1672);
                                                                                                    // Rule at src/opts/selects.isle line 89.
                                                                                                    returns.extend(Some(v1673));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Bmask => {
                                                                    if v2.0 == v1502.0 {
                                                                        let mut v1629 = C::inst_data_value_tupled_etor_returns::default();
                                                                        C::inst_data_value_tupled_etor(ctx, v84.1, &mut v1629);
                                                                        let mut v1629 = v1629.into_context_iter();
                                                                        while let Some(v1630) = v1629.next(ctx) {
                                                                            let v1631 = C::iconst_sextend_etor(ctx, v1630);
                                                                            if let Some(v1632) = v1631 {
                                                                                if v1632.1 == 1_i64 {
                                                                                    if v2.0 == v1632.0 {
                                                                                        let mut v1952 = C::inst_data_value_etor_returns::default();
                                                                                        C::inst_data_value_etor(ctx, v1660, &mut v1952);
                                                                                        let mut v1952 = v1952.into_context_iter();
                                                                                        while let Some(v1953) = v1952.next(ctx) {
                                                                                            if let &InstructionData::IntCompare {
                                                                                                opcode: ref v1956,
                                                                                                args: ref v1957,
                                                                                                cond: ref v1958,
                                                                                            } = &v1953.1 {
                                                                                                if let &Opcode::Icmp = v1956 {
                                                                                                    match v1958 {
                                                                                                        &IntCC::NotEqual => {
                                                                                                            if v89.0 == v1953.0 {
                                                                                                                let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                                                                let v1959 = C::unpack_value_array_2(ctx, v1957);
                                                                                                                if v1488.0 == v1959.0 {
                                                                                                                    if v1488.1 == v1959.1 {
                                                                                                                        let v1962 = constructor_spaceship_s(ctx, v89.0, v1488.0, v1488.1);
                                                                                                                        let v1963 = constructor_sextend_maybe(ctx, v2.0, v1962);
                                                                                                                        // Rule at src/opts/spaceship.isle line 133.
                                                                                                                        returns.extend(Some(v1963));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                        &IntCC::SignedLessThan => {
                                                                                                            if v89.0 == v1953.0 {
                                                                                                                let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                                                                let v1959 = C::unpack_value_array_2(ctx, v1957);
                                                                                                                if v1488.0 == v1959.0 {
                                                                                                                    if v1488.1 == v1959.1 {
                                                                                                                        let v1962 = constructor_spaceship_s(ctx, v89.0, v1488.0, v1488.1);
                                                                                                                        let v1963 = constructor_sextend_maybe(ctx, v2.0, v1962);
                                                                                                                        // Rule at src/opts/spaceship.isle line 123.
                                                                                                                        returns.extend(Some(v1963));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                        _ => {}
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                if v84.1 == v1488.0 {
                                                    if v84.2 == v1488.1 {
                                                        let v1642 = constructor_smax(ctx, v2.0, v1488.0, v1488.1);
                                                        // Rule at src/opts/selects.isle line 25.
                                                        returns.extend(Some(v1642));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v84.2 == v1488.0 {
                                                    if v84.1 == v1488.1 {
                                                        let v1644 = constructor_smin(ctx, v2.0, v1488.0, v1488.1);
                                                        // Rule at src/opts/selects.isle line 39.
                                                        returns.extend(Some(v1644));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::SignedGreaterThanOrEqual => {
                                                let mut v1501 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v84.2, &mut v1501);
                                                let mut v1501 = v1501.into_context_iter();
                                                while let Some(v1502) = v1501.next(ctx) {
                                                    match &v1502.1 {
                                                        &InstructionData::Unary {
                                                            opcode: ref v1659,
                                                            arg: v1660,
                                                        } => {
                                                            if let &Opcode::Ineg = v1659 {
                                                                if v2.0 == v1502.0 {
                                                                    let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                    if v84.1 == v1488.0 {
                                                                        if v84.1 == v1660 {
                                                                            let mut v1665 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v1488.1, &mut v1665);
                                                                            let mut v1665 = v1665.into_context_iter();
                                                                            while let Some(v1666) = v1665.next(ctx) {
                                                                                if let &InstructionData::UnaryImm {
                                                                                    opcode: ref v1669,
                                                                                    imm: v1670,
                                                                                } = &v1666.1 {
                                                                                    if let &Opcode::Iconst = v1669 {
                                                                                        let v1671 = C::u64_from_imm64(ctx, v1670);
                                                                                        if v1671 == 0x0_u64 {
                                                                                            if v2.0 == v1666.0 {
                                                                                                let v1672 = constructor_iabs(ctx, v2.0, v1488.0);
                                                                                                let v1673 = C::subsume(ctx, v1672);
                                                                                                // Rule at src/opts/selects.isle line 90.
                                                                                                returns.extend(Some(v1673));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::UnaryImm {
                                                            opcode: ref v1620,
                                                            imm: v1621,
                                                        } => {
                                                            if let &Opcode::Iconst = v1620 {
                                                                let v1622 = C::u64_from_imm64(ctx, v1621);
                                                                if v1622 == 0x1_u64 {
                                                                    if v2.0 == v1502.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 v1493,
                                                                                args: ref v1494,
                                                                                cond: ref v1495,
                                                                            } = &v95.1 {
                                                                                if let &Opcode::Icmp = v1493 {
                                                                                    match v1495 {
                                                                                        &IntCC::SignedGreaterThan => {
                                                                                            if v2.0 == v95.0 {
                                                                                                let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                                                let v1496 = C::unpack_value_array_2(ctx, v1494);
                                                                                                if v1488.0 == v1496.0 {
                                                                                                    if v1488.1 == v1496.1 {
                                                                                                        let v1759 = constructor_ne(ctx, v2.0, v1488.0, v1488.1);
                                                                                                        // Rule at src/opts/selects.isle line 163.
                                                                                                        returns.extend(Some(v1759));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                        &IntCC::SignedLessThan => {
                                                                                            if v2.0 == v95.0 {
                                                                                                let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                                                let v1496 = C::unpack_value_array_2(ctx, v1494);
                                                                                                if v1488.0 == v1496.1 {
                                                                                                    if v1488.1 == v1496.0 {
                                                                                                        let v1759 = constructor_ne(ctx, v2.0, v1488.0, v1488.1);
                                                                                                        // Rule at src/opts/selects.isle line 167.
                                                                                                        returns.extend(Some(v1759));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                        _ => {}
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                if v84.1 == v1488.0 {
                                                    if v84.2 == v1488.1 {
                                                        let v1642 = constructor_smax(ctx, v2.0, v1488.0, v1488.1);
                                                        // Rule at src/opts/selects.isle line 26.
                                                        returns.extend(Some(v1642));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v84.2 == v1488.0 {
                                                    if v84.1 == v1488.1 {
                                                        let v1644 = constructor_smin(ctx, v2.0, v1488.0, v1488.1);
                                                        // Rule at src/opts/selects.isle line 40.
                                                        returns.extend(Some(v1644));
                                                        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 v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                        if v84.2 == v1488.0 {
                                                                            let mut v1665 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v1488.1, &mut v1665);
                                                                            let mut v1665 = v1665.into_context_iter();
                                                                            while let Some(v1666) = v1665.next(ctx) {
                                                                                if let &InstructionData::UnaryImm {
                                                                                    opcode: ref v1669,
                                                                                    imm: v1670,
                                                                                } = &v1666.1 {
                                                                                    if let &Opcode::Iconst = v1669 {
                                                                                        let v1671 = C::u64_from_imm64(ctx, v1670);
                                                                                        if v1671 == 0x0_u64 {
                                                                                            if v2.0 == v1666.0 {
                                                                                                let v1672 = constructor_iabs(ctx, v2.0, v1488.0);
                                                                                                let v1673 = C::subsume(ctx, v1672);
                                                                                                // Rule at src/opts/selects.isle line 92.
                                                                                                returns.extend(Some(v1673));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::UnaryImm {
                                                            opcode: ref v1617,
                                                            imm: v1618,
                                                        } => {
                                                            if let &Opcode::Iconst = v1617 {
                                                                let v1619 = C::u64_from_imm64(ctx, v1618);
                                                                if v1619 == 0x1_u64 {
                                                                    if v2.0 == v95.0 {
                                                                        let mut v1501 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v84.2, &mut v1501);
                                                                        let mut v1501 = v1501.into_context_iter();
                                                                        while let Some(v1502) = v1501.next(ctx) {
                                                                            if let &InstructionData::IntCompare {
                                                                                opcode: ref v1505,
                                                                                args: ref v1506,
                                                                                cond: ref v1507,
                                                                            } = &v1502.1 {
                                                                                if let &Opcode::Icmp = v1505 {
                                                                                    match v1507 {
                                                                                        &IntCC::SignedGreaterThan => {
                                                                                            if v2.0 == v1502.0 {
                                                                                                let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                                                let v1508 = C::unpack_value_array_2(ctx, v1506);
                                                                                                if v1488.0 == v1508.0 {
                                                                                                    if v1488.1 == v1508.1 {
                                                                                                        let v1759 = constructor_ne(ctx, v2.0, v1488.0, v1488.1);
                                                                                                        // Rule at src/opts/selects.isle line 162.
                                                                                                        returns.extend(Some(v1759));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                        &IntCC::SignedLessThan => {
                                                                                            if v2.0 == v1502.0 {
                                                                                                let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                                                let v1508 = C::unpack_value_array_2(ctx, v1506);
                                                                                                if v1488.0 == v1508.1 {
                                                                                                    if v1488.1 == v1508.0 {
                                                                                                        let v1759 = constructor_ne(ctx, v2.0, v1488.0, v1488.1);
                                                                                                        // Rule at src/opts/selects.isle line 166.
                                                                                                        returns.extend(Some(v1759));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                        _ => {}
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let mut v1629 = C::inst_data_value_tupled_etor_returns::default();
                                                C::inst_data_value_tupled_etor(ctx, v84.1, &mut v1629);
                                                let mut v1629 = v1629.into_context_iter();
                                                while let Some(v1630) = v1629.next(ctx) {
                                                    let v1631 = C::iconst_sextend_etor(ctx, v1630);
                                                    if let Some(v1632) = v1631 {
                                                        if v1632.1 == -1_i64 {
                                                            if v2.0 == v1632.0 {
                                                                let mut v1914 = C::uextend_maybe_etor_returns::default();
                                                                C::uextend_maybe_etor(ctx, v84.2, &mut v1914);
                                                                let mut v1914 = v1914.into_context_iter();
                                                                while let Some(v1915) = v1914.next(ctx) {
                                                                    if v2.0 == v1915.0 {
                                                                        let mut v1918 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v1915.1, &mut v1918);
                                                                        let mut v1918 = v1918.into_context_iter();
                                                                        while let Some(v1919) = v1918.next(ctx) {
                                                                            if let &InstructionData::IntCompare {
                                                                                opcode: ref v1922,
                                                                                args: ref v1923,
                                                                                cond: ref v1924,
                                                                            } = &v1919.1 {
                                                                                if let &Opcode::Icmp = v1922 {
                                                                                    match v1924 {
                                                                                        &IntCC::NotEqual => {
                                                                                            if v89.0 == v1919.0 {
                                                                                                let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                                                let v1925 = C::unpack_value_array_2(ctx, v1923);
                                                                                                if v1488.0 == v1925.0 {
                                                                                                    if v1488.1 == v1925.1 {
                                                                                                        let v1962 = constructor_spaceship_s(ctx, v89.0, v1488.0, v1488.1);
                                                                                                        let v1963 = constructor_sextend_maybe(ctx, v2.0, v1962);
                                                                                                        // Rule at src/opts/spaceship.isle line 77.
                                                                                                        returns.extend(Some(v1963));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                        &IntCC::SignedGreaterThan => {
                                                                                            if v89.0 == v1919.0 {
                                                                                                let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                                                let v1925 = C::unpack_value_array_2(ctx, v1923);
                                                                                                if v1488.0 == v1925.0 {
                                                                                                    if v1488.1 == v1925.1 {
                                                                                                        let v1962 = constructor_spaceship_s(ctx, v89.0, v1488.0, v1488.1);
                                                                                                        let v1963 = constructor_sextend_maybe(ctx, v2.0, v1962);
                                                                                                        // Rule at src/opts/spaceship.isle line 83.
                                                                                                        returns.extend(Some(v1963));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                        _ => {}
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                if v84.1 == v1488.0 {
                                                    if v84.2 == v1488.1 {
                                                        let v1644 = constructor_smin(ctx, v2.0, v1488.0, v1488.1);
                                                        // Rule at src/opts/selects.isle line 29.
                                                        returns.extend(Some(v1644));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v84.1 == v1488.1 {
                                                    if v84.2 == v1488.0 {
                                                        let v1642 = constructor_smax(ctx, v2.0, v1488.0, v1488.1);
                                                        // Rule at src/opts/selects.isle line 35.
                                                        returns.extend(Some(v1642));
                                                        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 v1493,
                                                            args: ref v1494,
                                                            cond: ref v1495,
                                                        } => {
                                                            if let &Opcode::Icmp = v1493 {
                                                                match v1495 {
                                                                    &IntCC::SignedGreaterThan => {
                                                                        if v2.0 == v95.0 {
                                                                            let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                            let v1496 = C::unpack_value_array_2(ctx, v1494);
                                                                            if v1488.0 == v1496.1 {
                                                                                if v1488.1 == v1496.0 {
                                                                                    let mut v1501 = C::inst_data_value_etor_returns::default();
                                                                                    C::inst_data_value_etor(ctx, v84.2, &mut v1501);
                                                                                    let mut v1501 = v1501.into_context_iter();
                                                                                    while let Some(v1502) = v1501.next(ctx) {
                                                                                        if let &InstructionData::UnaryImm {
                                                                                            opcode: ref v1620,
                                                                                            imm: v1621,
                                                                                        } = &v1502.1 {
                                                                                            if let &Opcode::Iconst = v1620 {
                                                                                                let v1622 = C::u64_from_imm64(ctx, v1621);
                                                                                                if v1622 == 0x1_u64 {
                                                                                                    if v2.0 == v1502.0 {
                                                                                                        let v1760 = constructor_ne(ctx, v2.0, v1488.1, v1488.0);
                                                                                                        // Rule at src/opts/selects.isle line 165.
                                                                                                        returns.extend(Some(v1760));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedLessThan => {
                                                                        if v2.0 == v95.0 {
                                                                            let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                            let v1496 = C::unpack_value_array_2(ctx, v1494);
                                                                            if v1488.0 == v1496.0 {
                                                                                if v1488.1 == v1496.1 {
                                                                                    let mut v1501 = C::inst_data_value_etor_returns::default();
                                                                                    C::inst_data_value_etor(ctx, v84.2, &mut v1501);
                                                                                    let mut v1501 = v1501.into_context_iter();
                                                                                    while let Some(v1502) = v1501.next(ctx) {
                                                                                        if let &InstructionData::UnaryImm {
                                                                                            opcode: ref v1620,
                                                                                            imm: v1621,
                                                                                        } = &v1502.1 {
                                                                                            if let &Opcode::Iconst = v1620 {
                                                                                                let v1622 = C::u64_from_imm64(ctx, v1621);
                                                                                                if v1622 == 0x1_u64 {
                                                                                                    if v2.0 == v1502.0 {
                                                                                                        let v1760 = constructor_ne(ctx, v2.0, v1488.1, v1488.0);
                                                                                                        // Rule at src/opts/selects.isle line 169.
                                                                                                        returns.extend(Some(v1760));
                                                                                                        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 v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                        if v84.2 == v1488.0 {
                                                                            let mut v1665 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v1488.1, &mut v1665);
                                                                            let mut v1665 = v1665.into_context_iter();
                                                                            while let Some(v1666) = v1665.next(ctx) {
                                                                                if let &InstructionData::UnaryImm {
                                                                                    opcode: ref v1669,
                                                                                    imm: v1670,
                                                                                } = &v1666.1 {
                                                                                    if let &Opcode::Iconst = v1669 {
                                                                                        let v1671 = C::u64_from_imm64(ctx, v1670);
                                                                                        if v1671 == 0x0_u64 {
                                                                                            if v2.0 == v1666.0 {
                                                                                                let v1672 = constructor_iabs(ctx, v2.0, v1488.0);
                                                                                                let v1673 = C::subsume(ctx, v1672);
                                                                                                // Rule at src/opts/selects.isle line 91.
                                                                                                returns.extend(Some(v1673));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                if v84.1 == v1488.0 {
                                                    if v84.2 == v1488.1 {
                                                        let v1644 = constructor_smin(ctx, v2.0, v1488.0, v1488.1);
                                                        // Rule at src/opts/selects.isle line 30.
                                                        returns.extend(Some(v1644));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v84.1 == v1488.1 {
                                                    if v84.2 == v1488.0 {
                                                        let v1642 = constructor_smax(ctx, v2.0, v1488.0, v1488.1);
                                                        // Rule at src/opts/selects.isle line 36.
                                                        returns.extend(Some(v1642));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::UnsignedGreaterThan => {
                                                let mut v1501 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v84.2, &mut v1501);
                                                let mut v1501 = v1501.into_context_iter();
                                                while let Some(v1502) = v1501.next(ctx) {
                                                    match &v1502.1 {
                                                        &InstructionData::IntCompare {
                                                            opcode: ref v1505,
                                                            args: ref v1506,
                                                            cond: ref v1507,
                                                        } => {
                                                            if let &Opcode::Icmp = v1505 {
                                                                match v1507 {
                                                                    &IntCC::Equal => {
                                                                        if v2.0 == v1502.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 v1617,
                                                                                    imm: v1618,
                                                                                } = &v95.1 {
                                                                                    if let &Opcode::Iconst = v1617 {
                                                                                        let v1619 = C::u64_from_imm64(ctx, v1618);
                                                                                        if v1619 == 0x1_u64 {
                                                                                            if v2.0 == v95.0 {
                                                                                                let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                                                let v1508 = C::unpack_value_array_2(ctx, v1506);
                                                                                                if v1488.0 == v1508.0 {
                                                                                                    if v1488.1 == v1508.1 {
                                                                                                        let v1758 = constructor_ule(ctx, v2.0, v1488.1, v1488.0);
                                                                                                        // Rule at src/opts/selects.isle line 157.
                                                                                                        returns.extend(Some(v1758));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                                if v1488.0 == v1508.1 {
                                                                                                    if v1488.1 == v1508.0 {
                                                                                                        let v1758 = constructor_ule(ctx, v2.0, v1488.1, v1488.0);
                                                                                                        // Rule at src/opts/selects.isle line 153.
                                                                                                        returns.extend(Some(v1758));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedGreaterThan => {
                                                                        if v2.0 == v1502.0 {
                                                                            let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                            let v1508 = C::unpack_value_array_2(ctx, v1506);
                                                                            if v1488.0 == v1508.1 {
                                                                                if v1488.1 == v1508.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 v1617,
                                                                                            imm: v1618,
                                                                                        } = &v95.1 {
                                                                                            if let &Opcode::Iconst = v1617 {
                                                                                                let v1619 = C::u64_from_imm64(ctx, v1618);
                                                                                                if v1619 == 0x1_u64 {
                                                                                                    if v2.0 == v95.0 {
                                                                                                        let v1760 = constructor_ne(ctx, v2.0, v1488.1, v1488.0);
                                                                                                        // Rule at src/opts/selects.isle line 172.
                                                                                                        returns.extend(Some(v1760));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        if v2.0 == v1502.0 {
                                                                            let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                            let v1508 = C::unpack_value_array_2(ctx, v1506);
                                                                            if v1488.0 == v1508.0 {
                                                                                if v1488.1 == v1508.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 v1617,
                                                                                            imm: v1618,
                                                                                        } = &v95.1 {
                                                                                            if let &Opcode::Iconst = v1617 {
                                                                                                let v1619 = C::u64_from_imm64(ctx, v1618);
                                                                                                if v1619 == 0x1_u64 {
                                                                                                    if v2.0 == v95.0 {
                                                                                                        let v1760 = constructor_ne(ctx, v2.0, v1488.1, v1488.0);
                                                                                                        // Rule at src/opts/selects.isle line 176.
                                                                                                        returns.extend(Some(v1760));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v1659,
                                                            arg: v1660,
                                                        } => {
                                                            match v1659 {
                                                                &Opcode::Ineg => {
                                                                    if v89.0 == v1502.0 {
                                                                        let mut v1629 = C::inst_data_value_tupled_etor_returns::default();
                                                                        C::inst_data_value_tupled_etor(ctx, v84.1, &mut v1629);
                                                                        let mut v1629 = v1629.into_context_iter();
                                                                        while let Some(v1630) = v1629.next(ctx) {
                                                                            let v1631 = C::iconst_sextend_etor(ctx, v1630);
                                                                            if let Some(v1632) = v1631 {
                                                                                if v1632.1 == 1_i64 {
                                                                                    if v2.0 == v1632.0 {
                                                                                        let mut v1952 = C::inst_data_value_etor_returns::default();
                                                                                        C::inst_data_value_etor(ctx, v1660, &mut v1952);
                                                                                        let mut v1952 = v1952.into_context_iter();
                                                                                        while let Some(v1953) = v1952.next(ctx) {
                                                                                            if let &InstructionData::IntCompare {
                                                                                                opcode: ref v1956,
                                                                                                args: ref v1957,
                                                                                                cond: ref v1958,
                                                                                            } = &v1953.1 {
                                                                                                if let &Opcode::Icmp = v1956 {
                                                                                                    match v1958 {
                                                                                                        &IntCC::NotEqual => {
                                                                                                            if v89.0 == v1953.0 {
                                                                                                                let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                                                                let v1959 = C::unpack_value_array_2(ctx, v1957);
                                                                                                                if v1488.0 == v1959.0 {
                                                                                                                    if v1488.1 == v1959.1 {
                                                                                                                        let v1928 = constructor_spaceship_u(ctx, v89.0, v1488.0, v1488.1);
                                                                                                                        let v1929 = constructor_sextend_maybe(ctx, v2.0, v1928);
                                                                                                                        // Rule at src/opts/spaceship.isle line 64.
                                                                                                                        returns.extend(Some(v1929));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                        &IntCC::UnsignedLessThan => {
                                                                                                            if v89.0 == v1953.0 {
                                                                                                                let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                                                                let v1959 = C::unpack_value_array_2(ctx, v1957);
                                                                                                                if v1488.0 == v1959.0 {
                                                                                                                    if v1488.1 == v1959.1 {
                                                                                                                        let v1928 = constructor_spaceship_u(ctx, v89.0, v1488.0, v1488.1);
                                                                                                                        let v1929 = constructor_sextend_maybe(ctx, v2.0, v1928);
                                                                                                                        // Rule at src/opts/spaceship.isle line 54.
                                                                                                                        returns.extend(Some(v1929));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                        _ => {}
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Bmask => {
                                                                    if v2.0 == v1502.0 {
                                                                        let mut v1629 = C::inst_data_value_tupled_etor_returns::default();
                                                                        C::inst_data_value_tupled_etor(ctx, v84.1, &mut v1629);
                                                                        let mut v1629 = v1629.into_context_iter();
                                                                        while let Some(v1630) = v1629.next(ctx) {
                                                                            let v1631 = C::iconst_sextend_etor(ctx, v1630);
                                                                            if let Some(v1632) = v1631 {
                                                                                if v1632.1 == 1_i64 {
                                                                                    if v2.0 == v1632.0 {
                                                                                        let mut v1952 = C::inst_data_value_etor_returns::default();
                                                                                        C::inst_data_value_etor(ctx, v1660, &mut v1952);
                                                                                        let mut v1952 = v1952.into_context_iter();
                                                                                        while let Some(v1953) = v1952.next(ctx) {
                                                                                            if let &InstructionData::IntCompare {
                                                                                                opcode: ref v1956,
                                                                                                args: ref v1957,
                                                                                                cond: ref v1958,
                                                                                            } = &v1953.1 {
                                                                                                if let &Opcode::Icmp = v1956 {
                                                                                                    match v1958 {
                                                                                                        &IntCC::NotEqual => {
                                                                                                            if v89.0 == v1953.0 {
                                                                                                                let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                                                                let v1959 = C::unpack_value_array_2(ctx, v1957);
                                                                                                                if v1488.0 == v1959.0 {
                                                                                                                    if v1488.1 == v1959.1 {
                                                                                                                        let v1928 = constructor_spaceship_u(ctx, v89.0, v1488.0, v1488.1);
                                                                                                                        let v1929 = constructor_sextend_maybe(ctx, v2.0, v1928);
                                                                                                                        // Rule at src/opts/spaceship.isle line 68.
                                                                                                                        returns.extend(Some(v1929));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                        &IntCC::UnsignedLessThan => {
                                                                                                            if v89.0 == v1953.0 {
                                                                                                                let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                                                                let v1959 = C::unpack_value_array_2(ctx, v1957);
                                                                                                                if v1488.0 == v1959.0 {
                                                                                                                    if v1488.1 == v1959.1 {
                                                                                                                        let v1928 = constructor_spaceship_u(ctx, v89.0, v1488.0, v1488.1);
                                                                                                                        let v1929 = constructor_sextend_maybe(ctx, v2.0, v1928);
                                                                                                                        // Rule at src/opts/spaceship.isle line 58.
                                                                                                                        returns.extend(Some(v1929));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                        _ => {}
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                if v84.1 == v1488.0 {
                                                    if v84.2 == v1488.1 {
                                                        let v1643 = constructor_umax(ctx, v2.0, v1488.0, v1488.1);
                                                        // Rule at src/opts/selects.isle line 27.
                                                        returns.extend(Some(v1643));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v84.2 == v1488.0 {
                                                    if v84.1 == v1488.1 {
                                                        let v1645 = constructor_umin(ctx, v2.0, v1488.0, v1488.1);
                                                        // Rule at src/opts/selects.isle line 41.
                                                        returns.extend(Some(v1645));
                                                        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 v1493,
                                                        args: ref v1494,
                                                        cond: ref v1495,
                                                    } = &v95.1 {
                                                        if let &Opcode::Icmp = v1493 {
                                                            match v1495 {
                                                                &IntCC::Equal => {
                                                                    if v2.0 == v95.0 {
                                                                        let mut v1501 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v84.2, &mut v1501);
                                                                        let mut v1501 = v1501.into_context_iter();
                                                                        while let Some(v1502) = v1501.next(ctx) {
                                                                            if let &InstructionData::UnaryImm {
                                                                                opcode: ref v1620,
                                                                                imm: v1621,
                                                                            } = &v1502.1 {
                                                                                if let &Opcode::Iconst = v1620 {
                                                                                    let v1622 = C::u64_from_imm64(ctx, v1621);
                                                                                    if v1622 == 0x1_u64 {
                                                                                        if v2.0 == v1502.0 {
                                                                                            let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                                            let v1496 = C::unpack_value_array_2(ctx, v1494);
                                                                                            if v1488.0 == v1496.0 {
                                                                                                if v1488.1 == v1496.1 {
                                                                                                    let v1757 = constructor_ule(ctx, v2.0, v1488.0, v1488.1);
                                                                                                    // Rule at src/opts/selects.isle line 152.
                                                                                                    returns.extend(Some(v1757));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                            if v1488.0 == v1496.1 {
                                                                                                if v1488.1 == v1496.0 {
                                                                                                    let v1757 = constructor_ule(ctx, v2.0, v1488.0, v1488.1);
                                                                                                    // Rule at src/opts/selects.isle line 156.
                                                                                                    returns.extend(Some(v1757));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &IntCC::UnsignedGreaterThan => {
                                                                    if v2.0 == v95.0 {
                                                                        let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                        let v1496 = C::unpack_value_array_2(ctx, v1494);
                                                                        if v1488.0 == v1496.0 {
                                                                            if v1488.1 == v1496.1 {
                                                                                let mut v1501 = C::inst_data_value_etor_returns::default();
                                                                                C::inst_data_value_etor(ctx, v84.2, &mut v1501);
                                                                                let mut v1501 = v1501.into_context_iter();
                                                                                while let Some(v1502) = v1501.next(ctx) {
                                                                                    if let &InstructionData::UnaryImm {
                                                                                        opcode: ref v1620,
                                                                                        imm: v1621,
                                                                                    } = &v1502.1 {
                                                                                        if let &Opcode::Iconst = v1620 {
                                                                                            let v1622 = C::u64_from_imm64(ctx, v1621);
                                                                                            if v1622 == 0x1_u64 {
                                                                                                if v2.0 == v1502.0 {
                                                                                                    let v1759 = constructor_ne(ctx, v2.0, v1488.0, v1488.1);
                                                                                                    // Rule at src/opts/selects.isle line 171.
                                                                                                    returns.extend(Some(v1759));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &IntCC::UnsignedLessThan => {
                                                                    if v2.0 == v95.0 {
                                                                        let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                        let v1496 = C::unpack_value_array_2(ctx, v1494);
                                                                        if v1488.0 == v1496.1 {
                                                                            if v1488.1 == v1496.0 {
                                                                                let mut v1501 = C::inst_data_value_etor_returns::default();
                                                                                C::inst_data_value_etor(ctx, v84.2, &mut v1501);
                                                                                let mut v1501 = v1501.into_context_iter();
                                                                                while let Some(v1502) = v1501.next(ctx) {
                                                                                    if let &InstructionData::UnaryImm {
                                                                                        opcode: ref v1620,
                                                                                        imm: v1621,
                                                                                    } = &v1502.1 {
                                                                                        if let &Opcode::Iconst = v1620 {
                                                                                            let v1622 = C::u64_from_imm64(ctx, v1621);
                                                                                            if v1622 == 0x1_u64 {
                                                                                                if v2.0 == v1502.0 {
                                                                                                    let v1759 = constructor_ne(ctx, v2.0, v1488.0, v1488.1);
                                                                                                    // Rule at src/opts/selects.isle line 175.
                                                                                                    returns.extend(Some(v1759));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                    }
                                                }
                                                let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                if v84.1 == v1488.0 {
                                                    if v84.2 == v1488.1 {
                                                        let v1643 = constructor_umax(ctx, v2.0, v1488.0, v1488.1);
                                                        // Rule at src/opts/selects.isle line 28.
                                                        returns.extend(Some(v1643));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v84.1 == v1488.1 {
                                                    if v84.2 == v1488.0 {
                                                        let v1645 = constructor_umin(ctx, v2.0, v1488.0, v1488.1);
                                                        // Rule at src/opts/selects.isle line 42.
                                                        returns.extend(Some(v1645));
                                                        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 v1617,
                                                        imm: v1618,
                                                    } = &v95.1 {
                                                        if let &Opcode::Iconst = v1617 {
                                                            let v1619 = C::u64_from_imm64(ctx, v1618);
                                                            if v1619 == 0x1_u64 {
                                                                if v2.0 == v95.0 {
                                                                    let mut v1501 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v84.2, &mut v1501);
                                                                    let mut v1501 = v1501.into_context_iter();
                                                                    while let Some(v1502) = v1501.next(ctx) {
                                                                        if let &InstructionData::IntCompare {
                                                                            opcode: ref v1505,
                                                                            args: ref v1506,
                                                                            cond: ref v1507,
                                                                        } = &v1502.1 {
                                                                            if let &Opcode::Icmp = v1505 {
                                                                                match v1507 {
                                                                                    &IntCC::Equal => {
                                                                                        if v2.0 == v1502.0 {
                                                                                            let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                                            let v1508 = C::unpack_value_array_2(ctx, v1506);
                                                                                            if v1488.0 == v1508.0 {
                                                                                                if v1488.1 == v1508.1 {
                                                                                                    let v1757 = constructor_ule(ctx, v2.0, v1488.0, v1488.1);
                                                                                                    // Rule at src/opts/selects.isle line 151.
                                                                                                    returns.extend(Some(v1757));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                            if v1488.0 == v1508.1 {
                                                                                                if v1488.1 == v1508.0 {
                                                                                                    let v1757 = constructor_ule(ctx, v2.0, v1488.0, v1488.1);
                                                                                                    // Rule at src/opts/selects.isle line 155.
                                                                                                    returns.extend(Some(v1757));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                    &IntCC::UnsignedGreaterThan => {
                                                                                        if v2.0 == v1502.0 {
                                                                                            let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                                            let v1508 = C::unpack_value_array_2(ctx, v1506);
                                                                                            if v1488.0 == v1508.0 {
                                                                                                if v1488.1 == v1508.1 {
                                                                                                    let v1759 = constructor_ne(ctx, v2.0, v1488.0, v1488.1);
                                                                                                    // Rule at src/opts/selects.isle line 170.
                                                                                                    returns.extend(Some(v1759));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                    &IntCC::UnsignedLessThan => {
                                                                                        if v2.0 == v1502.0 {
                                                                                            let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                                            let v1508 = C::unpack_value_array_2(ctx, v1506);
                                                                                            if v1488.0 == v1508.1 {
                                                                                                if v1488.1 == v1508.0 {
                                                                                                    let v1759 = constructor_ne(ctx, v2.0, v1488.0, v1488.1);
                                                                                                    // Rule at src/opts/selects.isle line 174.
                                                                                                    returns.extend(Some(v1759));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                    _ => {}
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                let mut v1629 = C::inst_data_value_tupled_etor_returns::default();
                                                C::inst_data_value_tupled_etor(ctx, v84.1, &mut v1629);
                                                let mut v1629 = v1629.into_context_iter();
                                                while let Some(v1630) = v1629.next(ctx) {
                                                    let v1631 = C::iconst_sextend_etor(ctx, v1630);
                                                    if let Some(v1632) = v1631 {
                                                        if v1632.1 == -1_i64 {
                                                            if v2.0 == v1632.0 {
                                                                let mut v1914 = C::uextend_maybe_etor_returns::default();
                                                                C::uextend_maybe_etor(ctx, v84.2, &mut v1914);
                                                                let mut v1914 = v1914.into_context_iter();
                                                                while let Some(v1915) = v1914.next(ctx) {
                                                                    if v2.0 == v1915.0 {
                                                                        let mut v1918 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v1915.1, &mut v1918);
                                                                        let mut v1918 = v1918.into_context_iter();
                                                                        while let Some(v1919) = v1918.next(ctx) {
                                                                            if let &InstructionData::IntCompare {
                                                                                opcode: ref v1922,
                                                                                args: ref v1923,
                                                                                cond: ref v1924,
                                                                            } = &v1919.1 {
                                                                                if let &Opcode::Icmp = v1922 {
                                                                                    match v1924 {
                                                                                        &IntCC::NotEqual => {
                                                                                            if v89.0 == v1919.0 {
                                                                                                let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                                                let v1925 = C::unpack_value_array_2(ctx, v1923);
                                                                                                if v1488.0 == v1925.0 {
                                                                                                    if v1488.1 == v1925.1 {
                                                                                                        let v1928 = constructor_spaceship_u(ctx, v89.0, v1488.0, v1488.1);
                                                                                                        let v1929 = constructor_sextend_maybe(ctx, v2.0, v1928);
                                                                                                        // Rule at src/opts/spaceship.isle line 12.
                                                                                                        returns.extend(Some(v1929));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                        &IntCC::UnsignedGreaterThan => {
                                                                                            if v89.0 == v1919.0 {
                                                                                                let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                                                let v1925 = C::unpack_value_array_2(ctx, v1923);
                                                                                                if v1488.0 == v1925.0 {
                                                                                                    if v1488.1 == v1925.1 {
                                                                                                        let v1928 = constructor_spaceship_u(ctx, v89.0, v1488.0, v1488.1);
                                                                                                        let v1929 = constructor_sextend_maybe(ctx, v2.0, v1928);
                                                                                                        // Rule at src/opts/spaceship.isle line 18.
                                                                                                        returns.extend(Some(v1929));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                        _ => {}
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                if v84.1 == v1488.0 {
                                                    if v84.2 == v1488.1 {
                                                        let v1645 = constructor_umin(ctx, v2.0, v1488.0, v1488.1);
                                                        // Rule at src/opts/selects.isle line 31.
                                                        returns.extend(Some(v1645));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v84.1 == v1488.1 {
                                                    if v84.2 == v1488.0 {
                                                        let v1643 = constructor_umax(ctx, v2.0, v1488.0, v1488.1);
                                                        // Rule at src/opts/selects.isle line 37.
                                                        returns.extend(Some(v1643));
                                                        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 v1493,
                                                        args: ref v1494,
                                                        cond: ref v1495,
                                                    } = &v95.1 {
                                                        if let &Opcode::Icmp = v1493 {
                                                            match v1495 {
                                                                &IntCC::Equal => {
                                                                    if v2.0 == v95.0 {
                                                                        let mut v1501 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v84.2, &mut v1501);
                                                                        let mut v1501 = v1501.into_context_iter();
                                                                        while let Some(v1502) = v1501.next(ctx) {
                                                                            if let &InstructionData::UnaryImm {
                                                                                opcode: ref v1620,
                                                                                imm: v1621,
                                                                            } = &v1502.1 {
                                                                                if let &Opcode::Iconst = v1620 {
                                                                                    let v1622 = C::u64_from_imm64(ctx, v1621);
                                                                                    if v1622 == 0x1_u64 {
                                                                                        if v2.0 == v1502.0 {
                                                                                            let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                                            let v1496 = C::unpack_value_array_2(ctx, v1494);
                                                                                            if v1488.0 == v1496.0 {
                                                                                                if v1488.1 == v1496.1 {
                                                                                                    let v1758 = constructor_ule(ctx, v2.0, v1488.1, v1488.0);
                                                                                                    // Rule at src/opts/selects.isle line 158.
                                                                                                    returns.extend(Some(v1758));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                            if v1488.0 == v1496.1 {
                                                                                                if v1488.1 == v1496.0 {
                                                                                                    let v1758 = constructor_ule(ctx, v2.0, v1488.1, v1488.0);
                                                                                                    // Rule at src/opts/selects.isle line 154.
                                                                                                    returns.extend(Some(v1758));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &IntCC::UnsignedGreaterThan => {
                                                                    if v2.0 == v95.0 {
                                                                        let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                        let v1496 = C::unpack_value_array_2(ctx, v1494);
                                                                        if v1488.0 == v1496.1 {
                                                                            if v1488.1 == v1496.0 {
                                                                                let mut v1501 = C::inst_data_value_etor_returns::default();
                                                                                C::inst_data_value_etor(ctx, v84.2, &mut v1501);
                                                                                let mut v1501 = v1501.into_context_iter();
                                                                                while let Some(v1502) = v1501.next(ctx) {
                                                                                    if let &InstructionData::UnaryImm {
                                                                                        opcode: ref v1620,
                                                                                        imm: v1621,
                                                                                    } = &v1502.1 {
                                                                                        if let &Opcode::Iconst = v1620 {
                                                                                            let v1622 = C::u64_from_imm64(ctx, v1621);
                                                                                            if v1622 == 0x1_u64 {
                                                                                                if v2.0 == v1502.0 {
                                                                                                    let v1760 = constructor_ne(ctx, v2.0, v1488.1, v1488.0);
                                                                                                    // Rule at src/opts/selects.isle line 173.
                                                                                                    returns.extend(Some(v1760));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &IntCC::UnsignedLessThan => {
                                                                    if v2.0 == v95.0 {
                                                                        let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                        let v1496 = C::unpack_value_array_2(ctx, v1494);
                                                                        if v1488.0 == v1496.0 {
                                                                            if v1488.1 == v1496.1 {
                                                                                let mut v1501 = C::inst_data_value_etor_returns::default();
                                                                                C::inst_data_value_etor(ctx, v84.2, &mut v1501);
                                                                                let mut v1501 = v1501.into_context_iter();
                                                                                while let Some(v1502) = v1501.next(ctx) {
                                                                                    if let &InstructionData::UnaryImm {
                                                                                        opcode: ref v1620,
                                                                                        imm: v1621,
                                                                                    } = &v1502.1 {
                                                                                        if let &Opcode::Iconst = v1620 {
                                                                                            let v1622 = C::u64_from_imm64(ctx, v1621);
                                                                                            if v1622 == 0x1_u64 {
                                                                                                if v2.0 == v1502.0 {
                                                                                                    let v1760 = constructor_ne(ctx, v2.0, v1488.1, v1488.0);
                                                                                                    // Rule at src/opts/selects.isle line 177.
                                                                                                    returns.extend(Some(v1760));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                    }
                                                }
                                                let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                if v84.1 == v1488.0 {
                                                    if v84.2 == v1488.1 {
                                                        let v1645 = constructor_umin(ctx, v2.0, v1488.0, v1488.1);
                                                        // Rule at src/opts/selects.isle line 32.
                                                        returns.extend(Some(v1645));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v84.1 == v1488.1 {
                                                    if v84.2 == v1488.0 {
                                                        let v1643 = constructor_umax(ctx, v2.0, v1488.0, v1488.1);
                                                        // Rule at src/opts/selects.isle line 38.
                                                        returns.extend(Some(v1643));
                                                        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 v1617,
                                                imm: v1618,
                                            } = &v95.1 {
                                                if let &Opcode::Iconst = v1617 {
                                                    let v1619 = C::u64_from_imm64(ctx, v1618);
                                                    match v1619 {
                                                        0x0_u64 => {
                                                            let mut v1501 = C::inst_data_value_etor_returns::default();
                                                            C::inst_data_value_etor(ctx, v84.2, &mut v1501);
                                                            let mut v1501 = v1501.into_context_iter();
                                                            while let Some(v1502) = v1501.next(ctx) {
                                                                if let &InstructionData::UnaryImm {
                                                                    opcode: ref v1620,
                                                                    imm: v1621,
                                                                } = &v1502.1 {
                                                                    if let &Opcode::Iconst = v1620 {
                                                                        let v1622 = C::u64_from_imm64(ctx, v1621);
                                                                        let v1623 = C::u64_matches_non_zero(ctx, v1622);
                                                                        if let Some(v1624) = v1623 {
                                                                            if v1624 == true {
                                                                                let v1625 = &C::intcc_complement(ctx, v1487);
                                                                                let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                                                let v1626 = constructor_icmp(ctx, v89.0, v1625, v1488.0, v1488.1);
                                                                                let v1627 = constructor_select(ctx, v2.0, v1626, v84.2, v84.1);
                                                                                // Rule at src/opts/selects.isle line 8.
                                                                                returns.extend(Some(v1627));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        0x1_u64 => {
                                                            let mut v1501 = C::inst_data_value_etor_returns::default();
                                                            C::inst_data_value_etor(ctx, v84.2, &mut v1501);
                                                            let mut v1501 = v1501.into_context_iter();
                                                            while let Some(v1502) = v1501.next(ctx) {
                                                                if let &InstructionData::UnaryImm {
                                                                    opcode: ref v1620,
                                                                    imm: v1621,
                                                                } = &v1502.1 {
                                                                    if let &Opcode::Iconst = v1620 {
                                                                        let v1622 = C::u64_from_imm64(ctx, v1621);
                                                                        if v1622 == 0x0_u64 {
                                                                            let v1628 = constructor_uextend_maybe(ctx, v2.0, v84.0);
                                                                            // Rule at src/opts/selects.isle line 14.
                                                                            returns.extend(Some(v1628));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                            }
                                        }
                                        let mut v1629 = C::inst_data_value_tupled_etor_returns::default();
                                        C::inst_data_value_tupled_etor(ctx, v84.1, &mut v1629);
                                        let mut v1629 = v1629.into_context_iter();
                                        while let Some(v1630) = v1629.next(ctx) {
                                            let v1631 = C::iconst_sextend_etor(ctx, v1630);
                                            if let Some(v1632) = v1631 {
                                                if v1632.1 == -1_i64 {
                                                    let mut v1635 = C::inst_data_value_tupled_etor_returns::default();
                                                    C::inst_data_value_tupled_etor(ctx, v84.2, &mut v1635);
                                                    let mut v1635 = v1635.into_context_iter();
                                                    while let Some(v1636) = v1635.next(ctx) {
                                                        let v1637 = C::iconst_sextend_etor(ctx, v1636);
                                                        if let Some(v1638) = v1637 {
                                                            if v1638.1 == 0_i64 {
                                                                let v1641 = constructor_bmask(ctx, v2.0, v84.0);
                                                                // Rule at src/opts/selects.isle line 19.
                                                                returns.extend(Some(v1641));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v92,
                                    arg: v93,
                                } => {
                                    if let &Opcode::Uextend = v92 {
                                        let mut v1438 = C::inst_data_value_etor_returns::default();
                                        C::inst_data_value_etor(ctx, v93, &mut v1438);
                                        let mut v1438 = v1438.into_context_iter();
                                        while let Some(v1439) = v1438.next(ctx) {
                                            if let &InstructionData::IntCompare {
                                                opcode: ref v1442,
                                                args: ref v1443,
                                                cond: ref v1444,
                                            } = &v1439.1 {
                                                if let &Opcode::Icmp = v1442 {
                                                    let v1448 = constructor_select(ctx, v2.0, v93, v84.1, v84.2);
                                                    // Rule at src/opts/icmp.isle line 83.
                                                    returns.extend(Some(v1448));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v1062,
                                    imm: v1063,
                                } => {
                                    if let &Opcode::Iconst = v1062 {
                                        let v1064 = C::u64_from_imm64(ctx, v1063);
                                        if v1064 == 0x0_u64 {
                                            let v1068 = C::subsume(ctx, v84.2);
                                            // Rule at src/opts/cprop.isle line 228.
                                            returns.extend(Some(v1068));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        let v1065 = C::u64_matches_non_zero(ctx, v1064);
                                        if let Some(v1066) = v1065 {
                                            if v1066 == true {
                                                let v1067 = C::subsume(ctx, v84.1);
                                                // Rule at src/opts/cprop.isle line 226.
                                                returns.extend(Some(v1067));
                                                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 v1493,
                                    args: ref v1494,
                                    cond: ref v1495,
                                } => {
                                    if let &Opcode::Icmp = v1493 {
                                        if let &IntCC::Equal = v1495 {
                                            if v2.0 == v95.0 {
                                                let mut v1501 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v84.2, &mut v1501);
                                                let mut v1501 = v1501.into_context_iter();
                                                while let Some(v1502) = v1501.next(ctx) {
                                                    if let &InstructionData::IntCompare {
                                                        opcode: ref v1505,
                                                        args: ref v1506,
                                                        cond: ref v1507,
                                                    } = &v1502.1 {
                                                        if let &Opcode::Icmp = v1505 {
                                                            if let &IntCC::Equal = v1507 {
                                                                if v2.0 == v1502.0 {
                                                                    let v1508 = C::unpack_value_array_2(ctx, v1506);
                                                                    let mut v1786 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v1508.0, &mut v1786);
                                                                    let mut v1786 = v1786.into_context_iter();
                                                                    while let Some(v1787) = v1786.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v1790,
                                                                            imm: v1791,
                                                                        } = &v1787.1 {
                                                                            if let &Opcode::Iconst = v1790 {
                                                                                let v1496 = C::unpack_value_array_2(ctx, v1494);
                                                                                if v1496.0 == v1508.1 {
                                                                                    let v1792 = C::u64_from_imm64(ctx, v1791);
                                                                                    let v1793 = constructor_iconst_u(ctx, v1787.0, v1792);
                                                                                    let v1806 = constructor_select(ctx, v1787.0, v84.0, v1496.1, v1793);
                                                                                    let v1807 = constructor_eq(ctx, v2.0, v1496.0, v1806);
                                                                                    // Rule at src/opts/selects.isle line 193.
                                                                                    returns.extend(Some(v1807));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                                if v1496.1 == v1508.1 {
                                                                                    let v1792 = C::u64_from_imm64(ctx, v1791);
                                                                                    let v1793 = constructor_iconst_u(ctx, v1787.0, v1792);
                                                                                    let v1794 = constructor_select(ctx, v1787.0, v84.0, v1496.0, v1793);
                                                                                    let v1795 = constructor_eq(ctx, v2.0, v1496.1, v1794);
                                                                                    // Rule at src/opts/selects.isle line 191.
                                                                                    returns.extend(Some(v1795));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    let mut v1796 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v1508.1, &mut v1796);
                                                                    let mut v1796 = v1796.into_context_iter();
                                                                    while let Some(v1797) = v1796.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v1800,
                                                                            imm: v1801,
                                                                        } = &v1797.1 {
                                                                            if let &Opcode::Iconst = v1800 {
                                                                                let v1496 = C::unpack_value_array_2(ctx, v1494);
                                                                                if v1496.0 == v1508.0 {
                                                                                    let v1802 = C::u64_from_imm64(ctx, v1801);
                                                                                    let v1803 = constructor_iconst_u(ctx, v1797.0, v1802);
                                                                                    let v1808 = constructor_select(ctx, v1797.0, v84.0, v1496.1, v1803);
                                                                                    let v1809 = constructor_eq(ctx, v2.0, v1496.0, v1808);
                                                                                    // Rule at src/opts/selects.isle line 194.
                                                                                    returns.extend(Some(v1809));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                                if v1496.1 == v1508.0 {
                                                                                    let v1802 = C::u64_from_imm64(ctx, v1801);
                                                                                    let v1803 = constructor_iconst_u(ctx, v1797.0, v1802);
                                                                                    let v1804 = constructor_select(ctx, v1797.0, v84.0, v1496.0, v1803);
                                                                                    let v1805 = constructor_eq(ctx, v2.0, v1496.1, v1804);
                                                                                    // Rule at src/opts/selects.isle line 192.
                                                                                    returns.extend(Some(v1805));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::Ternary {
                                    opcode: ref v1704,
                                    args: ref v1705,
                                } => {
                                    if let &Opcode::Select = v1704 {
                                        if v2.0 == v95.0 {
                                            let v1706 = C::unpack_value_array_3(ctx, v1705);
                                            if v84.0 == v1706.0 {
                                                let v1710 = constructor_select(ctx, v2.0, v84.0, v1706.1, v84.2);
                                                // Rule at src/opts/selects.isle line 102.
                                                returns.extend(Some(v1710));
                                                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 v1501 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v84.2, &mut v1501);
                                                let mut v1501 = v1501.into_context_iter();
                                                while let Some(v1502) = v1501.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v1659,
                                                        arg: v1660,
                                                    } = &v1502.1 {
                                                        if let &Opcode::Uextend = v1659 {
                                                            if v2.0 == v1502.0 {
                                                                let v1658 = C::value_type(ctx, v99);
                                                                let v1661 = C::value_type(ctx, v1660);
                                                                if v1658 == v1661 {
                                                                    let v1662 = constructor_select(ctx, v1658, v84.0, v99, v1660);
                                                                    let v1663 = constructor_uextend(ctx, v2.0, v1662);
                                                                    // Rule at src/opts/selects.isle line 80.
                                                                    returns.extend(Some(v1663));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Sextend => {
                                            if v2.0 == v95.0 {
                                                let mut v1501 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v84.2, &mut v1501);
                                                let mut v1501 = v1501.into_context_iter();
                                                while let Some(v1502) = v1501.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v1659,
                                                        arg: v1660,
                                                    } = &v1502.1 {
                                                        if let &Opcode::Sextend = v1659 {
                                                            if v2.0 == v1502.0 {
                                                                let v1658 = C::value_type(ctx, v99);
                                                                let v1661 = C::value_type(ctx, v1660);
                                                                if v1658 == v1661 {
                                                                    let v1662 = constructor_select(ctx, v1658, v84.0, v99, v1660);
                                                                    let v1664 = constructor_sextend(ctx, v2.0, v1662);
                                                                    // Rule at src/opts/selects.isle line 84.
                                                                    returns.extend(Some(v1664));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v1617,
                                    imm: v1618,
                                } => {
                                    if let &Opcode::Iconst = v1617 {
                                        let v1619 = C::u64_from_imm64(ctx, v1618);
                                        if v1619 == 0x1_u64 {
                                            if v2.0 == v95.0 {
                                                let mut v1501 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v84.2, &mut v1501);
                                                let mut v1501 = v1501.into_context_iter();
                                                while let Some(v1502) = v1501.next(ctx) {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v1743,
                                                        args: ref v1744,
                                                    } = &v1502.1 {
                                                        if let &Opcode::Bor = v1743 {
                                                            if v2.0 == v1502.0 {
                                                                let v1745 = C::unpack_value_array_2(ctx, v1744);
                                                                if v84.0 == v1745.0 {
                                                                    let v1355 = constructor_iconst_u(ctx, v2.0, 0x1_u64);
                                                                    let v1761 = constructor_select(ctx, v2.0, v84.0, v1355, v1745.1);
                                                                    // Rule at src/opts/selects.isle line 180.
                                                                    returns.extend(Some(v1761));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v84.0 == v1745.1 {
                                                                    let v1355 = constructor_iconst_u(ctx, v2.0, 0x1_u64);
                                                                    let v1762 = constructor_select(ctx, v2.0, v84.0, v1355, v1745.0);
                                                                    // Rule at src/opts/selects.isle line 181.
                                                                    returns.extend(Some(v1762));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                        if v84.1 == v84.2 {
                            let v1067 = C::subsume(ctx, v84.1);
                            // Rule at src/opts/selects.isle line 3.
                            returns.extend(Some(v1067));
                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                        }
                        let mut v378 = ContextIterWrapper::<ConstructorVec<_>, _>::default();
                        constructor_truthy(ctx, v84.0, &mut v378);
                        let mut v378 = v378.into_context_iter();
                        while let Some(v379) = v378.next(ctx) {
                            let v380 = constructor_select(ctx, v2.0, v379, v84.1, v84.2);
                            // Rule at src/opts/bitops.isle line 112.
                            returns.extend(Some(v380));
                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                        }
                        let mut v1501 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v84.2, &mut v1501);
                        let mut v1501 = v1501.into_context_iter();
                        while let Some(v1502) = v1501.next(ctx) {
                            if let &InstructionData::Ternary {
                                opcode: ref v1697,
                                args: ref v1698,
                            } = &v1502.1 {
                                if let &Opcode::Select = v1697 {
                                    if v2.0 == v1502.0 {
                                        let v1699 = C::unpack_value_array_3(ctx, v1698);
                                        if v84.0 == v1699.0 {
                                            let v1703 = constructor_select(ctx, v2.0, v84.0, v84.1, v1699.2);
                                            // Rule at src/opts/selects.isle line 101.
                                            returns.extend(Some(v1703));
                                            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 v1062,
                                imm: v1063,
                            } = &v89.1 {
                                if let &Opcode::Iconst = v1062 {
                                    let v1064 = C::u64_from_imm64(ctx, v1063);
                                    if v1064 == 0x0_u64 {
                                        let v1068 = C::subsume(ctx, v84.2);
                                        // Rule at src/opts/spectre.isle line 13.
                                        returns.extend(Some(v1068));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                    let v1065 = C::u64_matches_non_zero(ctx, v1064);
                                    if let Some(v1066) = v1065 {
                                        if v1066 == true {
                                            let v1067 = C::subsume(ctx, v84.1);
                                            // Rule at src/opts/spectre.isle line 11.
                                            returns.extend(Some(v1067));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                            }
                        }
                        if v84.1 == v84.2 {
                            let v1067 = C::subsume(ctx, v84.1);
                            // Rule at src/opts/spectre.isle line 9.
                            returns.extend(Some(v1067));
                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                        }
                    }
                    &Opcode::Bitselect => {
                        let v1646 = C::multi_lane(ctx, v2.0);
                        if let Some(v1647) = v1646 {
                            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 v1485,
                                    args: ref v1486,
                                    cond: ref v1487,
                                } = &v89.1 {
                                    if let &Opcode::Icmp = v1485 {
                                        match v1487 {
                                            &IntCC::SignedGreaterThan => {
                                                let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                if v84.1 == v1488.0 {
                                                    if v84.2 == v1488.1 {
                                                        let v1642 = constructor_smax(ctx, v2.0, v1488.0, v1488.1);
                                                        // Rule at src/opts/selects.isle line 45.
                                                        returns.extend(Some(v1642));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v84.1 == v1488.1 {
                                                    if v84.2 == v1488.0 {
                                                        let v1644 = constructor_smin(ctx, v2.0, v1488.0, v1488.1);
                                                        // Rule at src/opts/selects.isle line 59.
                                                        returns.extend(Some(v1644));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::SignedGreaterThanOrEqual => {
                                                let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                if v84.1 == v1488.0 {
                                                    if v84.2 == v1488.1 {
                                                        let v1642 = constructor_smax(ctx, v2.0, v1488.0, v1488.1);
                                                        // Rule at src/opts/selects.isle line 46.
                                                        returns.extend(Some(v1642));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v84.1 == v1488.1 {
                                                    if v84.2 == v1488.0 {
                                                        let v1644 = constructor_smin(ctx, v2.0, v1488.0, v1488.1);
                                                        // Rule at src/opts/selects.isle line 60.
                                                        returns.extend(Some(v1644));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::SignedLessThan => {
                                                let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                if v84.1 == v1488.0 {
                                                    if v84.2 == v1488.1 {
                                                        let v1644 = constructor_smin(ctx, v2.0, v1488.0, v1488.1);
                                                        // Rule at src/opts/selects.isle line 49.
                                                        returns.extend(Some(v1644));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v84.1 == v1488.1 {
                                                    if v84.2 == v1488.0 {
                                                        let v1642 = constructor_smax(ctx, v2.0, v1488.0, v1488.1);
                                                        // Rule at src/opts/selects.isle line 55.
                                                        returns.extend(Some(v1642));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::SignedLessThanOrEqual => {
                                                let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                if v84.1 == v1488.0 {
                                                    if v84.2 == v1488.1 {
                                                        let v1644 = constructor_smin(ctx, v2.0, v1488.0, v1488.1);
                                                        // Rule at src/opts/selects.isle line 50.
                                                        returns.extend(Some(v1644));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v84.1 == v1488.1 {
                                                    if v84.2 == v1488.0 {
                                                        let v1642 = constructor_smax(ctx, v2.0, v1488.0, v1488.1);
                                                        // Rule at src/opts/selects.isle line 56.
                                                        returns.extend(Some(v1642));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::UnsignedGreaterThan => {
                                                let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                if v84.1 == v1488.0 {
                                                    if v84.2 == v1488.1 {
                                                        let v1643 = constructor_umax(ctx, v2.0, v1488.0, v1488.1);
                                                        // Rule at src/opts/selects.isle line 47.
                                                        returns.extend(Some(v1643));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v84.1 == v1488.1 {
                                                    if v84.2 == v1488.0 {
                                                        let v1645 = constructor_umin(ctx, v2.0, v1488.0, v1488.1);
                                                        // Rule at src/opts/selects.isle line 61.
                                                        returns.extend(Some(v1645));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::UnsignedGreaterThanOrEqual => {
                                                let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                if v84.1 == v1488.0 {
                                                    if v84.2 == v1488.1 {
                                                        let v1643 = constructor_umax(ctx, v2.0, v1488.0, v1488.1);
                                                        // Rule at src/opts/selects.isle line 48.
                                                        returns.extend(Some(v1643));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v84.1 == v1488.1 {
                                                    if v84.2 == v1488.0 {
                                                        let v1645 = constructor_umin(ctx, v2.0, v1488.0, v1488.1);
                                                        // Rule at src/opts/selects.isle line 62.
                                                        returns.extend(Some(v1645));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::UnsignedLessThan => {
                                                let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                if v84.1 == v1488.0 {
                                                    if v84.2 == v1488.1 {
                                                        let v1645 = constructor_umin(ctx, v2.0, v1488.0, v1488.1);
                                                        // Rule at src/opts/selects.isle line 51.
                                                        returns.extend(Some(v1645));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v84.1 == v1488.1 {
                                                    if v84.2 == v1488.0 {
                                                        let v1643 = constructor_umax(ctx, v2.0, v1488.0, v1488.1);
                                                        // Rule at src/opts/selects.isle line 57.
                                                        returns.extend(Some(v1643));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::UnsignedLessThanOrEqual => {
                                                let v1488 = C::unpack_value_array_2(ctx, v1486);
                                                if v84.1 == v1488.0 {
                                                    if v84.2 == v1488.1 {
                                                        let v1645 = constructor_umin(ctx, v2.0, v1488.0, v1488.1);
                                                        // Rule at src/opts/selects.isle line 52.
                                                        returns.extend(Some(v1645));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v84.1 == v1488.1 {
                                                    if v84.2 == v1488.0 {
                                                        let v1643 = constructor_umax(ctx, v2.0, v1488.0, v1488.1);
                                                        // Rule at src/opts/selects.isle line 58.
                                                        returns.extend(Some(v1643));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                }
                            }
                        }
                        let v84 = C::unpack_value_array_3(ctx, v83);
                        if v84.1 == v84.2 {
                            let v1067 = C::subsume(ctx, v84.1);
                            // Rule at src/opts/selects.isle line 4.
                            returns.extend(Some(v1067));
                            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 v1095 = C::ty_vec128(ctx, v2.0);
                        if let Some(v1096) = v1095 {
                            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 v1112,
                                        imm: v1113,
                                    } => {
                                        if let &Opcode::F32const = v1112 {
                                            let v1114 = C::u32_from_ieee32(ctx, v1113);
                                            let v1115 = C::u32_into_u64(ctx, v1114);
                                            let v1116 = constructor_splat32(ctx, v1115);
                                            let v1117 = constructor_vconst(ctx, v1096, v1116);
                                            // Rule at src/opts/cprop.isle line 283.
                                            returns.extend(Some(v1117));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                    &InstructionData::UnaryIeee64 {
                                        opcode: ref v1118,
                                        imm: v1119,
                                    } => {
                                        if let &Opcode::F64const = v1118 {
                                            let v1120 = C::u64_from_ieee64(ctx, v1119);
                                            let v1121 = C::splat64(ctx, v1120);
                                            let v1122 = constructor_vconst(ctx, v1096, v1121);
                                            // Rule at src/opts/cprop.isle line 285.
                                            returns.extend(Some(v1122));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                    &InstructionData::UnaryImm {
                                        opcode: ref v949,
                                        imm: v950,
                                    } => {
                                        if let &Opcode::Iconst = v949 {
                                            match v35.0 {
                                                I8 => {
                                                    let v1097 = C::u64_uextend_imm64(ctx, I8, v950);
                                                    let v1098 = constructor_splat8(ctx, v1097);
                                                    let v1099 = constructor_vconst(ctx, v1096, v1098);
                                                    // Rule at src/opts/cprop.isle line 275.
                                                    returns.extend(Some(v1099));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                I16 => {
                                                    let v1101 = C::u64_uextend_imm64(ctx, I16, v950);
                                                    let v1102 = constructor_splat16(ctx, v1101);
                                                    let v1103 = constructor_vconst(ctx, v1096, v1102);
                                                    // Rule at src/opts/cprop.isle line 277.
                                                    returns.extend(Some(v1103));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                I32 => {
                                                    let v1105 = C::u64_uextend_imm64(ctx, I32, v950);
                                                    let v1106 = constructor_splat32(ctx, v1105);
                                                    let v1107 = constructor_vconst(ctx, v1096, v1106);
                                                    // Rule at src/opts/cprop.isle line 279.
                                                    returns.extend(Some(v1107));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                I64 => {
                                                    let v1109 = C::u64_uextend_imm64(ctx, I64, v950);
                                                    let v1110 = C::splat64(ctx, v1109);
                                                    let v1111 = constructor_vconst(ctx, v1096, v1110);
                                                    // Rule at src/opts/cprop.isle line 281.
                                                    returns.extend(Some(v1111));
                                                    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 v309 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v40.0, &mut v309);
                                                let mut v309 = v309.into_context_iter();
                                                while let Some(v310) = v309.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v313,
                                                        arg: v314,
                                                    } = &v310.1 {
                                                        if let &Opcode::Ineg = v313 {
                                                            if v2.0 == v310.0 {
                                                                let v315 = constructor_imul(ctx, v2.0, v40.1, v314);
                                                                // Rule at src/opts/arithmetic.isle line 411.
                                                                returns.extend(Some(v315));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                                let mut v316 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v40.1, &mut v316);
                                                let mut v316 = v316.into_context_iter();
                                                while let Some(v317) = v316.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v320,
                                                        arg: v321,
                                                    } = &v317.1 {
                                                        if let &Opcode::Ineg = v320 {
                                                            if v2.0 == v317.0 {
                                                                let v322 = constructor_imul(ctx, v2.0, v40.0, v321);
                                                                // Rule at src/opts/arithmetic.isle line 412.
                                                                returns.extend(Some(v322));
                                                                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 v316 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v40.1, &mut v316);
                                                let mut v316 = v316.into_context_iter();
                                                while let Some(v317) = v316.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v1338,
                                                        imm: v1339,
                                                    } = &v317.1 {
                                                        if let &Opcode::Iconst = v1338 {
                                                            let v1836 = C::u64_from_imm64(ctx, v1339);
                                                            let v363 = constructor_ty_shift_mask(ctx, v2.0);
                                                            let v1837 = C::u64_eq(ctx, v1836, v363);
                                                            if v1837 == true {
                                                                if v2.0 == v317.0 {
                                                                    let v1838 = constructor_sshr(ctx, v2.0, v40.0, v40.1);
                                                                    // Rule at src/opts/shifts.isle line 98.
                                                                    returns.extend(Some(v1838));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v45,
                                    arg: v46,
                                } => {
                                    match v45 {
                                        &Opcode::Splat => {
                                            if v2.0 == v35.0 {
                                                let v1854 = C::lane_type(ctx, v2.0);
                                                let v2010 = constructor_ineg(ctx, v1854, v46);
                                                let v2011 = constructor_splat(ctx, v2.0, v2010);
                                                // Rule at src/opts/vector.isle line 45.
                                                returns.extend(Some(v2011));
                                                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 v1854 = C::lane_type(ctx, v2.0);
                                            let v2012 = constructor_iabs(ctx, v1854, v46);
                                            let v2013 = constructor_splat(ctx, v2.0, v2012);
                                            // Rule at src/opts/vector.isle line 48.
                                            returns.extend(Some(v2013));
                                            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 v309 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v40.0, &mut v309);
                                                let mut v309 = v309.into_context_iter();
                                                while let Some(v310) = v309.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v313,
                                                        arg: v314,
                                                    } = &v310.1 {
                                                        if let &Opcode::Bnot = v313 {
                                                            if v2.0 == v310.0 {
                                                                let v791 = constructor_isub(ctx, v2.0, v314, v40.1);
                                                                // Rule at src/opts/bitops.isle line 410.
                                                                returns.extend(Some(v791));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                                let mut v316 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v40.1, &mut v316);
                                                let mut v316 = v316.into_context_iter();
                                                while let Some(v317) = v316.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v320,
                                                        arg: v321,
                                                    } = &v317.1 {
                                                        if let &Opcode::Bnot = v320 {
                                                            if v2.0 == v317.0 {
                                                                let v792 = constructor_isub(ctx, v2.0, v321, v40.0);
                                                                // Rule at src/opts/bitops.isle line 411.
                                                                returns.extend(Some(v792));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            let v339 = C::fits_in_64(ctx, v2.0);
                                            if let Some(v340) = v339 {
                                                if v35.0 == v340 {
                                                    let v40 = C::unpack_value_array_2(ctx, v39);
                                                    let mut v316 = C::inst_data_value_etor_returns::default();
                                                    C::inst_data_value_etor(ctx, v40.1, &mut v316);
                                                    let mut v316 = v316.into_context_iter();
                                                    while let Some(v317) = v316.next(ctx) {
                                                        if let &InstructionData::UnaryImm {
                                                            opcode: ref v1338,
                                                            imm: v1339,
                                                        } = &v317.1 {
                                                            if let &Opcode::Iconst = v1338 {
                                                                if v35.0 == v317.0 {
                                                                    let v1340 = constructor_bnot(ctx, v340, v40.0);
                                                                    let v1341 = C::imm64_neg(ctx, v340, v1339);
                                                                    let v1342 = constructor_iconst(ctx, v340, v1341);
                                                                    let v1343 = constructor_iadd(ctx, v340, v1340, v1342);
                                                                    // Rule at src/opts/cprop.isle line 501.
                                                                    returns.extend(Some(v1343));
                                                                    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 v309 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v40.0, &mut v309);
                                                let mut v309 = v309.into_context_iter();
                                                while let Some(v310) = v309.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v313,
                                                        arg: v314,
                                                    } = &v310.1 {
                                                        if let &Opcode::Bnot = v313 {
                                                            if v2.0 == v310.0 {
                                                                let v768 = constructor_bnot(ctx, v2.0, v40.1);
                                                                let v769 = constructor_bor(ctx, v2.0, v314, v768);
                                                                // Rule at src/opts/bitops.isle line 351.
                                                                returns.extend(Some(v769));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                                let mut v316 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v40.1, &mut v316);
                                                let mut v316 = v316.into_context_iter();
                                                while let Some(v317) = v316.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v320,
                                                        arg: v321,
                                                    } = &v317.1 {
                                                        if let &Opcode::Bnot = v320 {
                                                            if v2.0 == v317.0 {
                                                                let v770 = constructor_bnot(ctx, v2.0, v40.0);
                                                                let v771 = constructor_bor(ctx, v2.0, v321, v770);
                                                                // Rule at src/opts/bitops.isle line 352.
                                                                returns.extend(Some(v771));
                                                                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 v309 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v40.0, &mut v309);
                                                let mut v309 = v309.into_context_iter();
                                                while let Some(v310) = v309.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v313,
                                                        arg: v314,
                                                    } = &v310.1 {
                                                        if let &Opcode::Bnot = v313 {
                                                            if v2.0 == v310.0 {
                                                                let v768 = constructor_bnot(ctx, v2.0, v40.1);
                                                                let v772 = constructor_band(ctx, v2.0, v314, v768);
                                                                // Rule at src/opts/bitops.isle line 355.
                                                                returns.extend(Some(v772));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                                let mut v316 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v40.1, &mut v316);
                                                let mut v316 = v316.into_context_iter();
                                                while let Some(v317) = v316.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v320,
                                                        arg: v321,
                                                    } = &v317.1 {
                                                        if let &Opcode::Bnot = v320 {
                                                            if v2.0 == v317.0 {
                                                                let v770 = constructor_bnot(ctx, v2.0, v40.0);
                                                                let v773 = constructor_band(ctx, v2.0, v321, v770);
                                                                // Rule at src/opts/bitops.isle line 356.
                                                                returns.extend(Some(v773));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v45,
                                    arg: v46,
                                } => {
                                    match v45 {
                                        &Opcode::Splat => {
                                            let v1990 = C::ty_vector_not_float(ctx, v2.0);
                                            if let Some(v1991) = v1990 {
                                                if v2.0 == v35.0 {
                                                    let v1854 = C::lane_type(ctx, v2.0);
                                                    let v1998 = constructor_bnot(ctx, v1854, v46);
                                                    let v1999 = constructor_splat(ctx, v2.0, v1998);
                                                    // Rule at src/opts/vector.isle line 26.
                                                    returns.extend(Some(v1999));
                                                    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 v949,
                                    imm: v950,
                                } => {
                                    if let &Opcode::Iconst = v949 {
                                        let v339 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v340) = v339 {
                                            if v35.0 == v340 {
                                                let v975 = C::imm64_not(ctx, v340, v950);
                                                let v976 = constructor_iconst(ctx, v340, v975);
                                                let v977 = C::subsume(ctx, v976);
                                                // Rule at src/opts/cprop.isle line 73.
                                                returns.extend(Some(v977));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                        let v1610 = C::remat(ctx, arg0);
                        // Rule at src/opts/remat.isle line 23.
                        returns.extend(Some(v1610));
                        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 v339 = C::fits_in_64(ctx, v2.0);
                        if let Some(v340) = v339 {
                            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 v949,
                                    imm: v950,
                                } = &v35.1 {
                                    if let &Opcode::Iconst = v949 {
                                        if v35.0 == v340 {
                                            let v951 = C::imm64_clz(ctx, v340, v950);
                                            let v952 = constructor_iconst(ctx, v340, v951);
                                            let v953 = C::subsume(ctx, v952);
                                            // Rule at src/opts/cprop.isle line 2.
                                            returns.extend(Some(v953));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    &Opcode::Ctz => {
                        let v339 = C::fits_in_64(ctx, v2.0);
                        if let Some(v340) = v339 {
                            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 v949,
                                    imm: v950,
                                } = &v35.1 {
                                    if let &Opcode::Iconst = v949 {
                                        if v35.0 == v340 {
                                            let v954 = C::imm64_ctz(ctx, v340, v950);
                                            let v955 = constructor_iconst(ctx, v340, v954);
                                            let v956 = C::subsume(ctx, v955);
                                            // Rule at src/opts/cprop.isle line 8.
                                            returns.extend(Some(v956));
                                            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 v949,
                                    imm: v950,
                                } => {
                                    if let &Opcode::Iconst = v949 {
                                        match v2.0 {
                                            I16 => {
                                                let v1007 = C::u64_from_imm64(ctx, v950);
                                                let v1153 = C::u64_bswap16(ctx, v1007);
                                                let v1154 = C::imm64(ctx, v1153);
                                                let v1155 = constructor_iconst(ctx, I16, v1154);
                                                let v1156 = C::subsume(ctx, v1155);
                                                // Rule at src/opts/cprop.isle line 355.
                                                returns.extend(Some(v1156));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            I32 => {
                                                let v1007 = C::u64_from_imm64(ctx, v950);
                                                let v1157 = C::u64_bswap32(ctx, v1007);
                                                let v1158 = C::imm64(ctx, v1157);
                                                let v1159 = constructor_iconst(ctx, I32, v1158);
                                                let v1160 = C::subsume(ctx, v1159);
                                                // Rule at src/opts/cprop.isle line 357.
                                                returns.extend(Some(v1160));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            I64 => {
                                                let v1007 = C::u64_from_imm64(ctx, v950);
                                                let v1161 = C::u64_bswap64(ctx, v1007);
                                                let v1162 = C::imm64(ctx, v1161);
                                                let v1163 = constructor_iconst(ctx, I64, v1162);
                                                let v1164 = C::subsume(ctx, v1163);
                                                // Rule at src/opts/cprop.isle line 359.
                                                returns.extend(Some(v1164));
                                                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 v1854 = C::lane_type(ctx, v2.0);
                                        let v2014 = constructor_popcnt(ctx, v1854, v46);
                                        let v2015 = constructor_splat(ctx, v2.0, v2014);
                                        // Rule at src/opts/vector.isle line 51.
                                        returns.extend(Some(v2015));
                                        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 v1112,
                                            imm: v1113,
                                        } = &v35.1 {
                                            if let &Opcode::F32const = v1112 {
                                                let v1205 = C::f32_sqrt(ctx, v1113);
                                                if let Some(v1206) = v1205 {
                                                    let v1207 = constructor_f32const(ctx, F32, v1206);
                                                    let v1208 = C::subsume(ctx, v1207);
                                                    // Rule at src/opts/cprop.isle line 406.
                                                    returns.extend(Some(v1208));
                                                    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 v1118,
                                            imm: v1119,
                                        } = &v35.1 {
                                            if let &Opcode::F64const = v1118 {
                                                let v1209 = C::f64_sqrt(ctx, v1119);
                                                if let Some(v1210) = v1209 {
                                                    let v1211 = constructor_f64const(ctx, F64, v1210);
                                                    let v1212 = C::subsume(ctx, v1211);
                                                    // Rule at src/opts/cprop.isle line 409.
                                                    returns.extend(Some(v1212));
                                                    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 v1304,
                                    constant_handle: v1305,
                                } => {
                                    if let &Opcode::F128const = v1304 {
                                        if v2.0 == F128 {
                                            if v35.0 == F128 {
                                                let v1306 = C::ieee128_constant_extractor(ctx, v1305);
                                                if let Some(v1307) = v1306 {
                                                    let v1308 = C::f128_neg(ctx, v1307);
                                                    let v1309 = C::ieee128_constant(ctx, v1308);
                                                    let v1310 = constructor_f128const(ctx, F128, v1309);
                                                    let v1311 = C::subsume(ctx, v1310);
                                                    // Rule at src/opts/cprop.isle line 473.
                                                    returns.extend(Some(v1311));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryIeee16 {
                                    opcode: ref v1293,
                                    imm: v1294,
                                } => {
                                    if let &Opcode::F16const = v1293 {
                                        if v2.0 == F16 {
                                            if v35.0 == F16 {
                                                let v1295 = C::f16_neg(ctx, v1294);
                                                let v1296 = constructor_f16const(ctx, F16, v1295);
                                                let v1297 = C::subsume(ctx, v1296);
                                                // Rule at src/opts/cprop.isle line 467.
                                                returns.extend(Some(v1297));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryIeee32 {
                                    opcode: ref v1112,
                                    imm: v1113,
                                } => {
                                    if let &Opcode::F32const = v1112 {
                                        if v2.0 == F32 {
                                            if v35.0 == F32 {
                                                let v1298 = C::f32_neg(ctx, v1113);
                                                let v1299 = constructor_f32const(ctx, F32, v1298);
                                                let v1300 = C::subsume(ctx, v1299);
                                                // Rule at src/opts/cprop.isle line 469.
                                                returns.extend(Some(v1300));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryIeee64 {
                                    opcode: ref v1118,
                                    imm: v1119,
                                } => {
                                    if let &Opcode::F64const = v1118 {
                                        if v2.0 == F64 {
                                            if v35.0 == F64 {
                                                let v1301 = C::f64_neg(ctx, v1119);
                                                let v1302 = constructor_f64const(ctx, F64, v1301);
                                                let v1303 = C::subsume(ctx, v1302);
                                                // Rule at src/opts/cprop.isle line 471.
                                                returns.extend(Some(v1303));
                                                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 v1293,
                                            imm: v1294,
                                        } = &v35.1 {
                                            if let &Opcode::F16const = v1293 {
                                                let v1312 = C::f16_abs(ctx, v1294);
                                                let v1313 = constructor_f16const(ctx, F16, v1312);
                                                let v1314 = C::subsume(ctx, v1313);
                                                // Rule at src/opts/cprop.isle line 476.
                                                returns.extend(Some(v1314));
                                                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 v1112,
                                            imm: v1113,
                                        } = &v35.1 {
                                            if let &Opcode::F32const = v1112 {
                                                let v1315 = C::f32_abs(ctx, v1113);
                                                let v1316 = constructor_f32const(ctx, F32, v1315);
                                                let v1317 = C::subsume(ctx, v1316);
                                                // Rule at src/opts/cprop.isle line 478.
                                                returns.extend(Some(v1317));
                                                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 v1118,
                                            imm: v1119,
                                        } = &v35.1 {
                                            if let &Opcode::F64const = v1118 {
                                                let v1318 = C::f64_abs(ctx, v1119);
                                                let v1319 = constructor_f64const(ctx, F64, v1318);
                                                let v1320 = C::subsume(ctx, v1319);
                                                // Rule at src/opts/cprop.isle line 480.
                                                returns.extend(Some(v1320));
                                                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 v1304,
                                            constant_handle: v1305,
                                        } = &v35.1 {
                                            if let &Opcode::F128const = v1304 {
                                                let v1306 = C::ieee128_constant_extractor(ctx, v1305);
                                                if let Some(v1307) = v1306 {
                                                    let v1321 = C::f128_abs(ctx, v1307);
                                                    let v1322 = C::ieee128_constant(ctx, v1321);
                                                    let v1323 = constructor_f128const(ctx, F128, v1322);
                                                    let v1324 = C::subsume(ctx, v1323);
                                                    // Rule at src/opts/cprop.isle line 482.
                                                    returns.extend(Some(v1324));
                                                    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 v1112,
                                            imm: v1113,
                                        } = &v35.1 {
                                            if let &Opcode::F32const = v1112 {
                                                let v1213 = C::f32_ceil(ctx, v1113);
                                                if let Some(v1214) = v1213 {
                                                    let v1215 = constructor_f32const(ctx, F32, v1214);
                                                    let v1216 = C::subsume(ctx, v1215);
                                                    // Rule at src/opts/cprop.isle line 413.
                                                    returns.extend(Some(v1216));
                                                    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 v1118,
                                            imm: v1119,
                                        } = &v35.1 {
                                            if let &Opcode::F64const = v1118 {
                                                let v1217 = C::f64_ceil(ctx, v1119);
                                                if let Some(v1218) = v1217 {
                                                    let v1219 = constructor_f64const(ctx, F64, v1218);
                                                    let v1220 = C::subsume(ctx, v1219);
                                                    // Rule at src/opts/cprop.isle line 416.
                                                    returns.extend(Some(v1220));
                                                    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 v1112,
                                            imm: v1113,
                                        } = &v35.1 {
                                            if let &Opcode::F32const = v1112 {
                                                let v1221 = C::f32_floor(ctx, v1113);
                                                if let Some(v1222) = v1221 {
                                                    let v1223 = constructor_f32const(ctx, F32, v1222);
                                                    let v1224 = C::subsume(ctx, v1223);
                                                    // Rule at src/opts/cprop.isle line 420.
                                                    returns.extend(Some(v1224));
                                                    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 v1118,
                                            imm: v1119,
                                        } = &v35.1 {
                                            if let &Opcode::F64const = v1118 {
                                                let v1225 = C::f64_floor(ctx, v1119);
                                                if let Some(v1226) = v1225 {
                                                    let v1227 = constructor_f64const(ctx, F64, v1226);
                                                    let v1228 = C::subsume(ctx, v1227);
                                                    // Rule at src/opts/cprop.isle line 423.
                                                    returns.extend(Some(v1228));
                                                    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 v1112,
                                            imm: v1113,
                                        } = &v35.1 {
                                            if let &Opcode::F32const = v1112 {
                                                let v1229 = C::f32_trunc(ctx, v1113);
                                                if let Some(v1230) = v1229 {
                                                    let v1231 = constructor_f32const(ctx, F32, v1230);
                                                    let v1232 = C::subsume(ctx, v1231);
                                                    // Rule at src/opts/cprop.isle line 427.
                                                    returns.extend(Some(v1232));
                                                    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 v1118,
                                            imm: v1119,
                                        } = &v35.1 {
                                            if let &Opcode::F64const = v1118 {
                                                let v1233 = C::f64_trunc(ctx, v1119);
                                                if let Some(v1234) = v1233 {
                                                    let v1235 = constructor_f64const(ctx, F64, v1234);
                                                    let v1236 = C::subsume(ctx, v1235);
                                                    // Rule at src/opts/cprop.isle line 430.
                                                    returns.extend(Some(v1236));
                                                    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 v1112,
                                            imm: v1113,
                                        } = &v35.1 {
                                            if let &Opcode::F32const = v1112 {
                                                let v1237 = C::f32_nearest(ctx, v1113);
                                                if let Some(v1238) = v1237 {
                                                    let v1239 = constructor_f32const(ctx, F32, v1238);
                                                    let v1240 = C::subsume(ctx, v1239);
                                                    // Rule at src/opts/cprop.isle line 434.
                                                    returns.extend(Some(v1240));
                                                    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 v1118,
                                            imm: v1119,
                                        } = &v35.1 {
                                            if let &Opcode::F64const = v1118 {
                                                let v1241 = C::f64_nearest(ctx, v1119);
                                                if let Some(v1242) = v1241 {
                                                    let v1243 = constructor_f64const(ctx, F64, v1242);
                                                    let v1244 = C::subsume(ctx, v1243);
                                                    // Rule at src/opts/cprop.isle line 437.
                                                    returns.extend(Some(v1244));
                                                    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 v367,
                                        args: ref v368,
                                        cond: ref v369,
                                    } = &v35.1 {
                                        if let &Opcode::Icmp = v367 {
                                            let v374 = constructor_ineg(ctx, I8, v33);
                                            // Rule at src/opts/bitops.isle line 89.
                                            returns.extend(Some(v374));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                            }
                        }
                        let mut v375 = ContextIterWrapper::<ConstructorVec<_>, _>::default();
                        constructor_truthy(ctx, v33, &mut v375);
                        let mut v375 = v375.into_context_iter();
                        while let Some(v376) = v375.next(ctx) {
                            let v377 = constructor_bmask(ctx, v2.0, v376);
                            // Rule at src/opts/bitops.isle line 111.
                            returns.extend(Some(v377));
                            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 v1388 = constructor_ireduce(ctx, v2.0, v40.0);
                                            let v1389 = constructor_ireduce(ctx, v2.0, v40.1);
                                            let v1390 = constructor_iadd(ctx, v2.0, v1388, v1389);
                                            // Rule at src/opts/extends.isle line 85.
                                            returns.extend(Some(v1390));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Isub => {
                                            let v40 = C::unpack_value_array_2(ctx, v39);
                                            let v1388 = constructor_ireduce(ctx, v2.0, v40.0);
                                            let v1389 = constructor_ireduce(ctx, v2.0, v40.1);
                                            let v1391 = constructor_isub(ctx, v2.0, v1388, v1389);
                                            // Rule at src/opts/extends.isle line 86.
                                            returns.extend(Some(v1391));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Imul => {
                                            let v40 = C::unpack_value_array_2(ctx, v39);
                                            let v1388 = constructor_ireduce(ctx, v2.0, v40.0);
                                            let v1389 = constructor_ireduce(ctx, v2.0, v40.1);
                                            let v1392 = constructor_imul(ctx, v2.0, v1388, v1389);
                                            // Rule at src/opts/extends.isle line 87.
                                            returns.extend(Some(v1392));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Band => {
                                            let v40 = C::unpack_value_array_2(ctx, v39);
                                            let v1388 = constructor_ireduce(ctx, v2.0, v40.0);
                                            let v1389 = constructor_ireduce(ctx, v2.0, v40.1);
                                            let v1395 = constructor_band(ctx, v2.0, v1388, v1389);
                                            // Rule at src/opts/extends.isle line 90.
                                            returns.extend(Some(v1395));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Bor => {
                                            let v40 = C::unpack_value_array_2(ctx, v39);
                                            let v1388 = constructor_ireduce(ctx, v2.0, v40.0);
                                            let v1389 = constructor_ireduce(ctx, v2.0, v40.1);
                                            let v1393 = constructor_bor(ctx, v2.0, v1388, v1389);
                                            // Rule at src/opts/extends.isle line 88.
                                            returns.extend(Some(v1393));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Bxor => {
                                            let v40 = C::unpack_value_array_2(ctx, v39);
                                            let v1388 = constructor_ireduce(ctx, v2.0, v40.0);
                                            let v1389 = constructor_ireduce(ctx, v2.0, v40.1);
                                            let v1394 = constructor_bxor(ctx, v2.0, v1388, v1389);
                                            // Rule at src/opts/extends.isle line 89.
                                            returns.extend(Some(v1394));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v45,
                                    arg: v46,
                                } => {
                                    match v45 {
                                        &Opcode::Ineg => {
                                            let v1385 = constructor_ireduce(ctx, v2.0, v46);
                                            let v1386 = constructor_ineg(ctx, v2.0, v1385);
                                            // Rule at src/opts/extends.isle line 82.
                                            returns.extend(Some(v1386));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Bnot => {
                                            let v1385 = constructor_ireduce(ctx, v2.0, v46);
                                            let v1387 = constructor_bnot(ctx, v2.0, v1385);
                                            // Rule at src/opts/extends.isle line 83.
                                            returns.extend(Some(v1387));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Bmask => {
                                            let v388 = constructor_bmask(ctx, v2.0, v46);
                                            // Rule at src/opts/bitops.isle line 125.
                                            returns.extend(Some(v388));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Uextend => {
                                            let v344 = C::ty_int(ctx, v2.0);
                                            if let Some(v345) = v344 {
                                                let v1371 = C::ty_bits_u64(ctx, v345);
                                                let v1370 = C::value_type(ctx, v46);
                                                let v1372 = C::ty_bits_u64(ctx, v1370);
                                                let v1373 = C::u64_lt(ctx, v1371, v1372);
                                                if v1373 == true {
                                                    let v1374 = constructor_ireduce(ctx, v345, v46);
                                                    // Rule at src/opts/extends.isle line 57.
                                                    returns.extend(Some(v1374));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let v1375 = C::u64_lt(ctx, v1372, v1371);
                                                if v1375 == true {
                                                    let v1377 = constructor_uextend(ctx, v345, v46);
                                                    // Rule at src/opts/extends.isle line 64.
                                                    returns.extend(Some(v1377));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                            let v1370 = C::value_type(ctx, v46);
                                            if v2.0 == v1370 {
                                                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 v344 = C::ty_int(ctx, v2.0);
                                            if let Some(v345) = v344 {
                                                let v1371 = C::ty_bits_u64(ctx, v345);
                                                let v1370 = C::value_type(ctx, v46);
                                                let v1372 = C::ty_bits_u64(ctx, v1370);
                                                let v1373 = C::u64_lt(ctx, v1371, v1372);
                                                if v1373 == true {
                                                    let v1374 = constructor_ireduce(ctx, v345, v46);
                                                    // Rule at src/opts/extends.isle line 54.
                                                    returns.extend(Some(v1374));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let v1375 = C::u64_lt(ctx, v1372, v1371);
                                                if v1375 == true {
                                                    let v1376 = constructor_sextend(ctx, v345, v46);
                                                    // Rule at src/opts/extends.isle line 61.
                                                    returns.extend(Some(v1376));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                            let v1370 = C::value_type(ctx, v46);
                                            if v2.0 == v1370 {
                                                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 v949,
                                    imm: v950,
                                } => {
                                    if let &Opcode::Iconst = v949 {
                                        let v1005 = C::fits_in_64(ctx, v35.0);
                                        if let Some(v1006) = v1005 {
                                            let v1007 = C::u64_from_imm64(ctx, v950);
                                            let v1008 = C::imm64_masked(ctx, v2.0, v1007);
                                            let v1009 = constructor_iconst(ctx, v2.0, v1008);
                                            let v1010 = C::subsume(ctx, v1009);
                                            // Rule at src/opts/cprop.isle line 124.
                                            returns.extend(Some(v1010));
                                            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 v1854 = C::lane_type(ctx, v2.0);
                                    let v2034 = constructor_sextend(ctx, v1854, v46);
                                    let v2035 = constructor_splat(ctx, v2.0, v2034);
                                    // Rule at src/opts/vector.isle line 85.
                                    returns.extend(Some(v2035));
                                    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 v1854 = C::lane_type(ctx, v2.0);
                                    let v2034 = constructor_sextend(ctx, v1854, v46);
                                    let v2035 = constructor_splat(ctx, v2.0, v2034);
                                    // Rule at src/opts/vector.isle line 84.
                                    returns.extend(Some(v2035));
                                    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 v1854 = C::lane_type(ctx, v2.0);
                                    let v2036 = constructor_uextend(ctx, v1854, v46);
                                    let v2037 = constructor_splat(ctx, v2.0, v2036);
                                    // Rule at src/opts/vector.isle line 88.
                                    returns.extend(Some(v2037));
                                    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 v1854 = C::lane_type(ctx, v2.0);
                                    let v2036 = constructor_uextend(ctx, v1854, v46);
                                    let v2037 = constructor_splat(ctx, v2.0, v2036);
                                    // Rule at src/opts/vector.isle line 87.
                                    returns.extend(Some(v2037));
                                    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 v1344 = constructor_uextend(ctx, v2.0, v46);
                                        // Rule at src/opts/extends.isle line 1.
                                        returns.extend(Some(v1344));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v949,
                                    imm: v950,
                                } => {
                                    if let &Opcode::Iconst = v949 {
                                        let v339 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v340) = v339 {
                                            let v1007 = C::u64_from_imm64(ctx, v950);
                                            let v1011 = constructor_iconst_u(ctx, v340, v1007);
                                            let v1012 = C::subsume(ctx, v1011);
                                            // Rule at src/opts/cprop.isle line 129.
                                            returns.extend(Some(v1012));
                                            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 v367,
                                    args: ref v368,
                                    cond: ref v369,
                                } => {
                                    if let &Opcode::Icmp = v367 {
                                        let v1346 = constructor_uextend(ctx, v2.0, v33);
                                        // Rule at src/opts/extends.isle line 11.
                                        returns.extend(Some(v1346));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v45,
                                    arg: v46,
                                } => {
                                    match v45 {
                                        &Opcode::Bmask => {
                                            let v388 = constructor_bmask(ctx, v2.0, v46);
                                            // Rule at src/opts/bitops.isle line 124.
                                            returns.extend(Some(v388));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Uextend => {
                                            let v1344 = constructor_uextend(ctx, v2.0, v46);
                                            // Rule at src/opts/extends.isle line 7.
                                            returns.extend(Some(v1344));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Sextend => {
                                            let v1345 = constructor_sextend(ctx, v2.0, v46);
                                            // Rule at src/opts/extends.isle line 3.
                                            returns.extend(Some(v1345));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        _ => {}
                                    }
                                }
                                _ => {}
                            }
                        }
                        let v339 = C::fits_in_64(ctx, v2.0);
                        if let Some(v340) = v339 {
                            let mut v1013 = C::inst_data_value_tupled_etor_returns::default();
                            C::inst_data_value_tupled_etor(ctx, v33, &mut v1013);
                            let mut v1013 = v1013.into_context_iter();
                            while let Some(v1014) = v1013.next(ctx) {
                                let v1015 = C::iconst_sextend_etor(ctx, v1014);
                                if let Some(v1016) = v1015 {
                                    let v1019 = constructor_iconst_s(ctx, v340, v1016.1);
                                    let v1020 = C::subsume(ctx, v1019);
                                    // Rule at src/opts/cprop.isle line 131.
                                    returns.extend(Some(v1020));
                                    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 v1854 = C::lane_type(ctx, v2.0);
                                            let v1986 = constructor_fcvt_from_uint(ctx, v1854, v46);
                                            let v1987 = constructor_splat(ctx, v2.0, v1986);
                                            // Rule at src/opts/vector.isle line 6.
                                            returns.extend(Some(v1987));
                                            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 v949,
                                    imm: v950,
                                } => {
                                    if let &Opcode::Iconst = v949 {
                                        match v2.0 {
                                            F32 => {
                                                let v1007 = C::u64_from_imm64(ctx, v950);
                                                let v1144 = C::f32_from_uint(ctx, v1007);
                                                let v1145 = constructor_f32const(ctx, F32, v1144);
                                                // Rule at src/opts/cprop.isle line 336.
                                                returns.extend(Some(v1145));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            F64 => {
                                                let v1007 = C::u64_from_imm64(ctx, v950);
                                                let v1147 = C::f64_from_uint(ctx, v1007);
                                                let v1148 = constructor_f64const(ctx, F64, v1147);
                                                // Rule at src/opts/cprop.isle line 338.
                                                returns.extend(Some(v1148));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            _ => {}
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                    }
                    &Opcode::FcvtFromSint => {
                        match v2.0 {
                            F32 => {
                                let mut v1013 = C::inst_data_value_tupled_etor_returns::default();
                                C::inst_data_value_tupled_etor(ctx, v33, &mut v1013);
                                let mut v1013 = v1013.into_context_iter();
                                while let Some(v1014) = v1013.next(ctx) {
                                    let v1015 = C::iconst_sextend_etor(ctx, v1014);
                                    if let Some(v1016) = v1015 {
                                        let v1149 = C::f32_from_sint(ctx, v1016.1);
                                        let v1150 = constructor_f32const(ctx, F32, v1149);
                                        // Rule at src/opts/cprop.isle line 340.
                                        returns.extend(Some(v1150));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                            }
                            F64 => {
                                let mut v1013 = C::inst_data_value_tupled_etor_returns::default();
                                C::inst_data_value_tupled_etor(ctx, v33, &mut v1013);
                                let mut v1013 = v1013.into_context_iter();
                                while let Some(v1014) = v1013.next(ctx) {
                                    let v1015 = C::iconst_sextend_etor(ctx, v1014);
                                    if let Some(v1016) = v1015 {
                                        let v1151 = C::f64_from_sint(ctx, v1016.1);
                                        let v1152 = constructor_f64const(ctx, F64, v1151);
                                        // Rule at src/opts/cprop.isle line 342.
                                        returns.extend(Some(v1152));
                                        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 v1854 = C::lane_type(ctx, v2.0);
                                        let v1988 = constructor_fcvt_from_sint(ctx, v1854, v46);
                                        let v1989 = constructor_splat(ctx, v2.0, v1988);
                                        // Rule at src/opts/vector.isle line 8.
                                        returns.extend(Some(v1989));
                                        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 v1613,
                imm: v1614,
            } => {
                if let &Opcode::F32const = v1613 {
                    let v1610 = C::remat(ctx, arg0);
                    // Rule at src/opts/remat.isle line 27.
                    returns.extend(Some(v1610));
                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                }
            }
            &InstructionData::UnaryIeee64 {
                opcode: ref v1615,
                imm: v1616,
            } => {
                if let &Opcode::F64const = v1615 {
                    let v1610 = C::remat(ctx, arg0);
                    // Rule at src/opts/remat.isle line 29.
                    returns.extend(Some(v1610));
                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                }
            }
            &InstructionData::UnaryImm {
                opcode: ref v1611,
                imm: v1612,
            } => {
                if let &Opcode::Iconst = v1611 {
                    let v1610 = C::remat(ctx, arg0);
                    // Rule at src/opts/remat.isle line 25.
                    returns.extend(Some(v1610));
                    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 105.
    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 109.
    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 113.
    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 116.
    return v2;
}

// Generated as internal constructor for term replace_branch_cond.
pub fn constructor_replace_branch_cond<C: Context>(
    ctx: &mut C,
    arg0: Value,
) -> SkeletonInstSimplification {
    let v1 = SkeletonInstSimplification::ReplaceBranchCond {
        cond: arg0,
    };
    // Rule at src/prelude_opt.isle line 119.
    return v1;
}

// 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 v243,
                                    args: ref v244,
                                } => {
                                    if let &Opcode::Select = v243 {
                                        let v245 = C::unpack_value_array_3(ctx, v244);
                                        let mut v249 = C::inst_data_value_etor_returns::default();
                                        C::inst_data_value_etor(ctx, v245.1, &mut v249);
                                        let mut v249 = v249.into_context_iter();
                                        while let Some(v250) = v249.next(ctx) {
                                            if let &InstructionData::UnaryImm {
                                                opcode: ref v253,
                                                imm: v254,
                                            } = &v250.1 {
                                                if let &Opcode::Iconst = v253 {
                                                    let v255 = C::imm64_power_of_two(ctx, v254);
                                                    if let Some(v256) = v255 {
                                                        if v16.0 == v250.0 {
                                                            let mut v257 = C::inst_data_value_etor_returns::default();
                                                            C::inst_data_value_etor(ctx, v245.2, &mut v257);
                                                            let mut v257 = v257.into_context_iter();
                                                            while let Some(v258) = v257.next(ctx) {
                                                                if let &InstructionData::UnaryImm {
                                                                    opcode: ref v261,
                                                                    imm: v262,
                                                                } = &v258.1 {
                                                                    if let &Opcode::Iconst = v261 {
                                                                        let v263 = C::imm64_power_of_two(ctx, v262);
                                                                        if let Some(v264) = v263 {
                                                                            if v16.0 == v258.0 {
                                                                                let v265 = C::imm64(ctx, v256);
                                                                                let v266 = constructor_iconst(ctx, v16.0, v265);
                                                                                let v267 = C::imm64(ctx, v264);
                                                                                let v268 = constructor_iconst(ctx, v16.0, v267);
                                                                                let v269 = constructor_select(ctx, v16.0, v245.0, v266, v268);
                                                                                let v270 = constructor_ushr(ctx, v16.0, v5.0, v269);
                                                                                let v271 = &constructor_value_to_skeleton_inst_simplification(ctx, v270);
                                                                                // Rule at src/opts/skeleton.isle line 54.
                                                                                returns.extend(Some(v271.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::BranchTable {
                opcode: ref v230,
                arg: v231,
                table: v232,
            } => {
                if let &Opcode::BrTable = v230 {
                    let mut v233 = C::inst_data_value_etor_returns::default();
                    C::inst_data_value_etor(ctx, v231, &mut v233);
                    let mut v233 = v233.into_context_iter();
                    while let Some(v234) = v233.next(ctx) {
                        if let &InstructionData::UnaryImm {
                            opcode: ref v237,
                            imm: v238,
                        } = &v234.1 {
                            if let &Opcode::Iconst = v237 {
                                let v239 = C::u64_from_imm64(ctx, v238);
                                let v240 = C::resolve_jump_table_entry(ctx, v232, v239);
                                let v241 = constructor_jump(ctx, v240);
                                let v242 = &constructor_inst_to_skeleton_inst_simplification(ctx, v241);
                                // Rule at src/opts/skeleton.isle line 30.
                                returns.extend(Some(v242.clone()));
                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                            }
                        }
                    }
                }
            }
            &InstructionData::Brif {
                opcode: ref v143,
                arg: v144,
                blocks: ref v145,
            } => {
                if let &Opcode::Brif = v143 {
                    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) {
                        match &v147.1 {
                            &InstructionData::Unary {
                                opcode: ref v150,
                                arg: v151,
                            } => {
                                match v150 {
                                    &Opcode::Clz => {
                                        let v161 = constructor_iconst_u(ctx, v147.0, 0x0_u64);
                                        let v162 = constructor_sge(ctx, I8, v151, v161);
                                        let v163 = &constructor_replace_branch_cond(ctx, v162);
                                        // Rule at src/opts/icmp.isle line 465.
                                        returns.extend(Some(v163.clone()));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                    &Opcode::Ctz => {
                                        let v156 = constructor_iconst_u(ctx, v147.0, 0x1_u64);
                                        let v157 = constructor_band(ctx, v147.0, v151, v156);
                                        let v158 = constructor_iconst_u(ctx, v147.0, 0x0_u64);
                                        let v159 = constructor_eq(ctx, I8, v157, v158);
                                        let v160 = &constructor_replace_branch_cond(ctx, v159);
                                        // Rule at src/opts/icmp.isle line 460.
                                        returns.extend(Some(v160.clone()));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                    &Opcode::Ireduce => {
                                        let mut v164 = C::inst_data_value_etor_returns::default();
                                        C::inst_data_value_etor(ctx, v151, &mut v164);
                                        let mut v164 = v164.into_context_iter();
                                        while let Some(v165) = v164.next(ctx) {
                                            if let &InstructionData::Unary {
                                                opcode: ref v168,
                                                arg: v169,
                                            } = &v165.1 {
                                                match v168 {
                                                    &Opcode::Clz => {
                                                        let v175 = constructor_iconst_u(ctx, v165.0, 0x0_u64);
                                                        let v176 = constructor_sge(ctx, I8, v169, v175);
                                                        let v177 = &constructor_replace_branch_cond(ctx, v176);
                                                        // Rule at src/opts/icmp.isle line 474.
                                                        returns.extend(Some(v177.clone()));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                    &Opcode::Ctz => {
                                                        let v170 = constructor_iconst_u(ctx, v165.0, 0x1_u64);
                                                        let v171 = constructor_band(ctx, v165.0, v169, v170);
                                                        let v172 = constructor_iconst_u(ctx, v165.0, 0x0_u64);
                                                        let v173 = constructor_eq(ctx, I8, v171, v172);
                                                        let v174 = &constructor_replace_branch_cond(ctx, v173);
                                                        // Rule at src/opts/icmp.isle line 470.
                                                        returns.extend(Some(v174.clone()));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                    _ => {}
                                                }
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                            &InstructionData::UnaryImm {
                                opcode: ref v221,
                                imm: v222,
                            } => {
                                if let &Opcode::Iconst = v221 {
                                    let v223 = C::u64_from_imm64(ctx, v222);
                                    if v223 == 0x0_u64 {
                                        let v152 = C::unpack_block_array_2(ctx, v145);
                                        let v228 = constructor_jump(ctx, v152.1);
                                        let v229 = &constructor_inst_to_skeleton_inst_simplification(ctx, v228);
                                        // Rule at src/opts/skeleton.isle line 25.
                                        returns.extend(Some(v229.clone()));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                    let v224 = C::u64_matches_non_zero(ctx, v223);
                                    if let Some(v225) = v224 {
                                        if v225 == true {
                                            let v152 = C::unpack_block_array_2(ctx, v145);
                                            let v226 = constructor_jump(ctx, v152.0);
                                            let v227 = &constructor_inst_to_skeleton_inst_simplification(ctx, v226);
                                            // Rule at src/opts/skeleton.isle line 21.
                                            returns.extend(Some(v227.clone()));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                            }
                            _ => {}
                        }
                    }
                }
            }
            &InstructionData::CondTrap {
                opcode: ref v178,
                arg: v179,
                code: ref v180,
            } => {
                match v178 {
                    &Opcode::Trapz => {
                        let mut v181 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v179, &mut v181);
                        let mut v181 = v181.into_context_iter();
                        while let Some(v182) = v181.next(ctx) {
                            if let &InstructionData::UnaryImm {
                                opcode: ref v185,
                                imm: v186,
                            } = &v182.1 {
                                if let &Opcode::Iconst = v185 {
                                    let v187 = C::u64_from_imm64(ctx, v186);
                                    let v188 = C::u64_matches_non_zero(ctx, v187);
                                    if let Some(v189) = v188 {
                                        if v189 == true {
                                            let v190 = &constructor_remove_inst(ctx);
                                            // Rule at src/opts/skeleton.isle line 6.
                                            returns.extend(Some(v190.clone()));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    &Opcode::Trapnz => {
                        let mut v181 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v179, &mut v181);
                        let mut v181 = v181.into_context_iter();
                        while let Some(v182) = v181.next(ctx) {
                            if let &InstructionData::UnaryImm {
                                opcode: ref v185,
                                imm: v186,
                            } = &v182.1 {
                                if let &Opcode::Iconst = v185 {
                                    let v187 = C::u64_from_imm64(ctx, v186);
                                    if v187 == 0x0_u64 {
                                        let v190 = &constructor_remove_inst(ctx);
                                        // Rule at src/opts/skeleton.isle line 8.
                                        returns.extend(Some(v190.clone()));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                            }
                        }
                    }
                    _ => {}
                }
            }
            &InstructionData::IntAddTrap {
                opcode: ref v191,
                args: ref v192,
                code: ref v193,
            } => {
                if let &Opcode::UaddOverflowTrap = v191 {
                    let v194 = C::unpack_value_array_2(ctx, v192);
                    let mut v197 = C::inst_data_value_etor_returns::default();
                    C::inst_data_value_etor(ctx, v194.0, &mut v197);
                    let mut v197 = v197.into_context_iter();
                    while let Some(v198) = v197.next(ctx) {
                        match &v198.1 {
                            &InstructionData::Unary {
                                opcode: ref v215,
                                arg: v216,
                            } => {
                                if let &Opcode::Uextend = v215 {
                                    let mut v204 = C::inst_data_value_etor_returns::default();
                                    C::inst_data_value_etor(ctx, v194.1, &mut v204);
                                    let mut v204 = v204.into_context_iter();
                                    while let Some(v205) = v204.next(ctx) {
                                        if let &InstructionData::Unary {
                                            opcode: ref v217,
                                            arg: v218,
                                        } = &v205.1 {
                                            if let &Opcode::Uextend = v217 {
                                                if v198.0 == v205.0 {
                                                    let v219 = constructor_iadd(ctx, v198.0, v194.0, v194.1);
                                                    let v220 = &constructor_value_to_skeleton_inst_simplification(ctx, v219);
                                                    // Rule at src/opts/skeleton.isle line 17.
                                                    returns.extend(Some(v220.clone()));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            &InstructionData::UnaryImm {
                                opcode: ref v201,
                                imm: v202,
                            } => {
                                if let &Opcode::Iconst = v201 {
                                    let mut v204 = C::inst_data_value_etor_returns::default();
                                    C::inst_data_value_etor(ctx, v194.1, &mut v204);
                                    let mut v204 = v204.into_context_iter();
                                    while let Some(v205) = v204.next(ctx) {
                                        if let &InstructionData::UnaryImm {
                                            opcode: ref v208,
                                            imm: v209,
                                        } = &v205.1 {
                                            if let &Opcode::Iconst = v208 {
                                                let v203 = C::u64_from_imm64(ctx, v202);
                                                let v210 = C::u64_from_imm64(ctx, v209);
                                                let v211 = C::checked_add_with_type(ctx, v198.0, v203, v210);
                                                if let Some(v212) = v211 {
                                                    if v198.0 == v205.0 {
                                                        let v213 = constructor_iconst_u(ctx, v198.0, v212);
                                                        let v214 = &constructor_value_to_skeleton_inst_simplification(ctx, v213);
                                                        // Rule at src/opts/skeleton.isle line 12.
                                                        returns.extend(Some(v214.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 173.
        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 172.
        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 166.
                return v12;
            }
        }
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "iconst_s", "src/prelude_opt.isle line 164")
}

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

// 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 209.
        return arg1;
    }
    let v2 = constructor_uextend(ctx, arg0, arg1);
    // Rule at src/prelude_opt.isle line 208.
    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 215.
        return arg1;
    }
    let v2 = constructor_sextend(ctx, arg0, arg1);
    // Rule at src/prelude_opt.isle line 214.
    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 44.
    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 45.
    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 46.
    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 47.
    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 48.
    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 49.
    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 50.
    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 51.
    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 52.
    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 53.
    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 252.
    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 256.
        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 259.
        return v3;
    }
    let v5 = false;
    // Rule at src/prelude_opt.isle line 262.
    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 291.
    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 296.
        return v11;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "apply_div_const_magic_u32_inner", "src/prelude_opt.isle line 295")
}

// 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 321.
                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 312.
                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 311")
}

// 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 335.
            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 341.
                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 334")
}

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

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

// 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 398.
                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 389.
                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 388")
}

// 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 412.
            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 418.
                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 411")
}

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

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

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

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

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

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

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

// 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 385.
        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 384.
        return v4;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "cmp_true", "src/opts/arithmetic.isle line 383")
}

// 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 351.
    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 360.
    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 369.
    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 378.
    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 387.
    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 396.
    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 405.
    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 414.
    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 423.
    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 432.
    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 441.
    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 450.
    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 459.
    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 468.
    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 477.
    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 486.
    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 495.
    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 504.
    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 513.
    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 522.
    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 531.
    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 540.
    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 549.
    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 558.
    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 567.
    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 576.
    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 585.
    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 594.
    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 603.
    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 612.
    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 621.
    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 630.
    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 639.
    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 648.
    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 657.
    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 666.
    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 675.
    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 684.
    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 693.
    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 702.
    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 711.
    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 720.
    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 729.
    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 738.
    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 747.
    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 756.
    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 765.
    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 774.
    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 783.
    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 792.
    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 801.
    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 810.
    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 819.
    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 828.
    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 837.
    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 846.
    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 855.
    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 864.
    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 873.
    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 882.
    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 891.
    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 900.
    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 909.
    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 918.
    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 927.
    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 936.
    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 945.
    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 954.
    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 963.
    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 972.
    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 981.
    return v7;
}

// 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 990.
    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 999.
    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 1008.
    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 1017.
    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 1026.
    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 1035.
    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 1044.
    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 1053.
    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 1062.
    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 1071.
    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 1080.
    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 1089.
    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 1098.
    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 1107.
    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 1116.
    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 1125.
    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 1134.
    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 1143.
    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 1152.
    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 1161.
    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 1170.
    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 1179.
    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 1188.
    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 1197.
    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 1206.
    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 1215.
    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 1224.
    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 1233.
    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 1242.
    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 1251.
    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 1260.
    return v6;
}

// 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 1269.
    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 1278.
    return v6;
}

// 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 1287.
    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 1296.
    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 1305.
    return v6;
}

// 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 1314.
    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 1323.
    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 1332.
    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 1341.
    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 1350.
    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 1359.
    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 1368.
    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 1377.
    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 1386.
    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 1395.
    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 1404.
    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 1413.
    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 1422.
    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 1431.
    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 1440.
    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 1449.
    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 1458.
    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 1467.
    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 1476.
    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 1485.
    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 1494.
    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 1503.
    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 1512.
    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 1521.
    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 1530.
    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 1539.
    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 1548.
    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 1557.
    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 1566.
    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 1575.
    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 1584.
    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 1593.
    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 1602.
    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 1611.
    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 1620.
    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 1629.
    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 1638.
    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 1647.
    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 1656.
    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 1665.
    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 1674.
    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 1683.
    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 1692.
    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 1701.
    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 1710.
    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 1719.
    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 1728.
    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 1737.
    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 1746.
    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 1755.
    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 1764.
    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 1773.
    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 1782.
    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 1791.
    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 1800.
    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 1809.
    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 1818.
    return v2;
}
