// 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(&mut self, arg0: Type) -> Option<Type>;
    fn ty_int_ref_scalar_64_extract(&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 block_call_block(&mut self, arg0: BlockCall) -> Block;
    fn just_trap_block(&mut self, arg0: &Block) -> Option<TrapCode>;
    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 79.
#[derive(Clone, Debug)]
pub enum SkeletonInstSimplification {
    Remove,
    RemoveWithVal {
        val: Value,
    },
    Replace {
        inst: Inst,
    },
    ReplaceWithVal {
        inst: Inst,
        val: Value,
    },
    ReplaceBranchCond {
        cond: Value,
    },
    ReplaceWithTwo {
        first: Inst,
        second: Inst,
    },
}

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

/// Internal type DivConstMagicS64: defined at src/prelude_opt.isle line 297.
#[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 342.
    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 67.
    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 70.
    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 v97,
                                    args: ref v98,
                                } => {
                                    match v97 {
                                        &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 v133,
                                                            args: ref v134,
                                                        } => {
                                                            match v133 {
                                                                &Opcode::Smax => {
                                                                    if v2.0 == v11.0 {
                                                                        let v99 = C::unpack_value_array_2(ctx, v98);
                                                                        let v135 = C::unpack_value_array_2(ctx, v134);
                                                                        if v99.0 == v135.0 {
                                                                            if v99.1 == v135.1 {
                                                                                let v326 = constructor_smin(ctx, v2.0, v99.0, v99.1);
                                                                                // Rule at src/opts/arithmetic.isle line 482.
                                                                                returns.extend(Some(v326));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                        if v99.0 == v135.1 {
                                                                            if v99.1 == v135.0 {
                                                                                let v326 = constructor_smin(ctx, v2.0, v99.0, v99.1);
                                                                                // Rule at src/opts/arithmetic.isle line 483.
                                                                                returns.extend(Some(v326));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Umax => {
                                                                    if v2.0 == v11.0 {
                                                                        let v99 = C::unpack_value_array_2(ctx, v98);
                                                                        let v135 = C::unpack_value_array_2(ctx, v134);
                                                                        if v99.0 == v135.0 {
                                                                            if v99.1 == v135.1 {
                                                                                let v326 = constructor_smin(ctx, v2.0, v99.0, v99.1);
                                                                                // Rule at src/opts/arithmetic.isle line 484.
                                                                                returns.extend(Some(v326));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                        if v99.0 == v135.1 {
                                                                            if v99.1 == v135.0 {
                                                                                let v326 = constructor_smin(ctx, v2.0, v99.0, v99.1);
                                                                                // Rule at src/opts/arithmetic.isle line 485.
                                                                                returns.extend(Some(v326));
                                                                                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 v99 = C::unpack_value_array_2(ctx, v98);
                                                                    let mut v109 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                                    let mut v109 = v109.into_context_iter();
                                                                    while let Some(v110) = v109.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v127,
                                                                            imm: v128,
                                                                        } = &v110.1 {
                                                                            if let &Opcode::Iconst = v127 {
                                                                                if v2.0 == v110.0 {
                                                                                    let v1068 = constructor_smin(ctx, v2.0, v99.1, v7.1);
                                                                                    let v1069 = constructor_smin(ctx, v2.0, v99.0, v1068);
                                                                                    // Rule at src/opts/cprop.isle line 237.
                                                                                    returns.extend(Some(v1069));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let v99 = C::unpack_value_array_2(ctx, v98);
                                                if v7.1 == v99.0 {
                                                    let v326 = constructor_smin(ctx, v2.0, v99.0, v99.1);
                                                    // Rule at src/opts/arithmetic.isle line 449.
                                                    returns.extend(Some(v326));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.1 == v99.1 {
                                                    let v327 = constructor_smin(ctx, v2.0, v99.1, v99.0);
                                                    // Rule at src/opts/arithmetic.isle line 450.
                                                    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 v133,
                                                        args: ref v134,
                                                    } = &v11.1 {
                                                        match v133 {
                                                            &Opcode::Smax => {
                                                                if v2.0 == v11.0 {
                                                                    let v99 = C::unpack_value_array_2(ctx, v98);
                                                                    let v135 = C::unpack_value_array_2(ctx, v134);
                                                                    if v99.0 == v135.0 {
                                                                        if v99.1 == v135.1 {
                                                                            let v330 = constructor_umin(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/arithmetic.isle line 492.
                                                                            returns.extend(Some(v330));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v99.0 == v135.1 {
                                                                        if v99.1 == v135.0 {
                                                                            let v330 = constructor_umin(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/arithmetic.isle line 493.
                                                                            returns.extend(Some(v330));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Umax => {
                                                                if v2.0 == v11.0 {
                                                                    let v99 = C::unpack_value_array_2(ctx, v98);
                                                                    let v135 = C::unpack_value_array_2(ctx, v134);
                                                                    if v99.0 == v135.0 {
                                                                        if v99.1 == v135.1 {
                                                                            let v326 = constructor_smin(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/arithmetic.isle line 494.
                                                                            returns.extend(Some(v326));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v99.0 == v135.1 {
                                                                        if v99.1 == v135.0 {
                                                                            let v326 = constructor_smin(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/arithmetic.isle line 495.
                                                                            returns.extend(Some(v326));
                                                                            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 v133,
                                                        args: ref v134,
                                                    } = &v11.1 {
                                                        match v133 {
                                                            &Opcode::Smin => {
                                                                if v2.0 == v11.0 {
                                                                    let v99 = C::unpack_value_array_2(ctx, v98);
                                                                    let v135 = C::unpack_value_array_2(ctx, v134);
                                                                    if v99.0 == v135.0 {
                                                                        if v99.1 == v135.1 {
                                                                            let v326 = constructor_smin(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/arithmetic.isle line 477.
                                                                            returns.extend(Some(v326));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v99.0 == v135.1 {
                                                                        if v99.1 == v135.0 {
                                                                            let v326 = constructor_smin(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/arithmetic.isle line 478.
                                                                            returns.extend(Some(v326));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Umin => {
                                                                if v2.0 == v11.0 {
                                                                    let v99 = C::unpack_value_array_2(ctx, v98);
                                                                    let v135 = C::unpack_value_array_2(ctx, v134);
                                                                    if v99.0 == v135.0 {
                                                                        if v99.1 == v135.1 {
                                                                            let v330 = constructor_umin(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/arithmetic.isle line 479.
                                                                            returns.extend(Some(v330));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v99.0 == v135.1 {
                                                                        if v99.1 == v135.0 {
                                                                            let v330 = constructor_umin(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/arithmetic.isle line 480.
                                                                            returns.extend(Some(v330));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                    }
                                                }
                                                let v99 = C::unpack_value_array_2(ctx, v98);
                                                if v7.1 == v99.0 {
                                                    // Rule at src/opts/arithmetic.isle line 460.
                                                    returns.extend(Some(v99.0));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.1 == v99.1 {
                                                    // Rule at src/opts/arithmetic.isle line 459.
                                                    returns.extend(Some(v99.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 v133,
                                                        args: ref v134,
                                                    } = &v11.1 {
                                                        match v133 {
                                                            &Opcode::Smin => {
                                                                if v2.0 == v11.0 {
                                                                    let v99 = C::unpack_value_array_2(ctx, v98);
                                                                    let v135 = C::unpack_value_array_2(ctx, v134);
                                                                    if v99.0 == v135.0 {
                                                                        if v99.1 == v135.1 {
                                                                            let v326 = constructor_smin(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/arithmetic.isle line 487.
                                                                            returns.extend(Some(v326));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v99.0 == v135.1 {
                                                                        if v99.1 == v135.0 {
                                                                            let v326 = constructor_smin(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/arithmetic.isle line 488.
                                                                            returns.extend(Some(v326));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Umin => {
                                                                if v2.0 == v11.0 {
                                                                    let v99 = C::unpack_value_array_2(ctx, v98);
                                                                    let v135 = C::unpack_value_array_2(ctx, v134);
                                                                    if v99.0 == v135.0 {
                                                                        if v99.1 == v135.1 {
                                                                            let v326 = constructor_smin(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/arithmetic.isle line 489.
                                                                            returns.extend(Some(v326));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v99.0 == v135.1 {
                                                                        if v99.1 == v135.0 {
                                                                            let v326 = constructor_smin(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/arithmetic.isle line 490.
                                                                            returns.extend(Some(v326));
                                                                            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 v1849 = C::lane_type(ctx, v2.0);
                                                            let v2011 = constructor_smin(ctx, v1849, v30, v27);
                                                            let v2012 = constructor_splat(ctx, v2.0, v2011);
                                                            // Rule at src/opts/vector.isle line 54.
                                                            returns.extend(Some(v2012));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v22,
                                    imm: v23,
                                } => {
                                    if let &Opcode::Iconst = v22 {
                                        let v334 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v335) = v334 {
                                            if v19.0 == v335 {
                                                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 v994 = C::imm64_smin(ctx, v335, v23, v15);
                                                                let v995 = constructor_iconst(ctx, v335, v994);
                                                                let v996 = C::subsume(ctx, v995);
                                                                // Rule at src/opts/cprop.isle line 113.
                                                                returns.extend(Some(v996));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        if v2.0 == v19.0 {
                                            let v1026 = constructor_smin(ctx, v2.0, v7.1, v7.0);
                                            // Rule at src/opts/cprop.isle line 168.
                                            returns.extend(Some(v1026));
                                            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 v133,
                                args: ref v134,
                            } = &v11.1 {
                                match v133 {
                                    &Opcode::Smin => {
                                        if v2.0 == v11.0 {
                                            let v135 = C::unpack_value_array_2(ctx, v134);
                                            if v7.0 == v135.0 {
                                                let v328 = constructor_smin(ctx, v2.0, v7.0, v135.1);
                                                // Rule at src/opts/arithmetic.isle line 451.
                                                returns.extend(Some(v328));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            if v7.0 == v135.1 {
                                                let v329 = constructor_smin(ctx, v2.0, v7.0, v135.0);
                                                // Rule at src/opts/arithmetic.isle line 452.
                                                returns.extend(Some(v329));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                    &Opcode::Smax => {
                                        if v2.0 == v11.0 {
                                            let v135 = C::unpack_value_array_2(ctx, v134);
                                            if v7.0 == v135.0 {
                                                // Rule at src/opts/arithmetic.isle line 462.
                                                returns.extend(Some(v7.0));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            if v7.0 == v135.1 {
                                                // Rule at src/opts/arithmetic.isle line 461.
                                                returns.extend(Some(v7.0));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                        }
                        if v7.0 == v7.1 {
                            // Rule at src/opts/arithmetic.isle line 434.
                            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 v97,
                                    args: ref v98,
                                } => {
                                    match v97 {
                                        &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 v133,
                                                        args: ref v134,
                                                    } = &v11.1 {
                                                        match v133 {
                                                            &Opcode::Smax => {
                                                                if v2.0 == v11.0 {
                                                                    let v99 = C::unpack_value_array_2(ctx, v98);
                                                                    let v135 = C::unpack_value_array_2(ctx, v134);
                                                                    if v99.0 == v135.0 {
                                                                        if v99.1 == v135.1 {
                                                                            let v330 = constructor_umin(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/arithmetic.isle line 502.
                                                                            returns.extend(Some(v330));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v99.0 == v135.1 {
                                                                        if v99.1 == v135.0 {
                                                                            let v330 = constructor_umin(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/arithmetic.isle line 503.
                                                                            returns.extend(Some(v330));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Umax => {
                                                                if v2.0 == v11.0 {
                                                                    let v99 = C::unpack_value_array_2(ctx, v98);
                                                                    let v135 = C::unpack_value_array_2(ctx, v134);
                                                                    if v99.0 == v135.0 {
                                                                        if v99.1 == v135.1 {
                                                                            let v326 = constructor_smin(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/arithmetic.isle line 504.
                                                                            returns.extend(Some(v326));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v99.0 == v135.1 {
                                                                        if v99.1 == v135.0 {
                                                                            let v326 = constructor_smin(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/arithmetic.isle line 505.
                                                                            returns.extend(Some(v326));
                                                                            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 v133,
                                                            args: ref v134,
                                                        } => {
                                                            match v133 {
                                                                &Opcode::Smax => {
                                                                    if v2.0 == v11.0 {
                                                                        let v99 = C::unpack_value_array_2(ctx, v98);
                                                                        let v135 = C::unpack_value_array_2(ctx, v134);
                                                                        if v99.0 == v135.0 {
                                                                            if v99.1 == v135.1 {
                                                                                let v330 = constructor_umin(ctx, v2.0, v99.0, v99.1);
                                                                                // Rule at src/opts/arithmetic.isle line 512.
                                                                                returns.extend(Some(v330));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                        if v99.0 == v135.1 {
                                                                            if v99.1 == v135.0 {
                                                                                let v330 = constructor_umin(ctx, v2.0, v99.0, v99.1);
                                                                                // Rule at src/opts/arithmetic.isle line 513.
                                                                                returns.extend(Some(v330));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Umax => {
                                                                    if v2.0 == v11.0 {
                                                                        let v99 = C::unpack_value_array_2(ctx, v98);
                                                                        let v135 = C::unpack_value_array_2(ctx, v134);
                                                                        if v99.0 == v135.0 {
                                                                            if v99.1 == v135.1 {
                                                                                let v330 = constructor_umin(ctx, v2.0, v99.0, v99.1);
                                                                                // Rule at src/opts/arithmetic.isle line 514.
                                                                                returns.extend(Some(v330));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                        if v99.0 == v135.1 {
                                                                            if v99.1 == v135.0 {
                                                                                let v330 = constructor_umin(ctx, v2.0, v99.0, v99.1);
                                                                                // Rule at src/opts/arithmetic.isle line 515.
                                                                                returns.extend(Some(v330));
                                                                                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 v99 = C::unpack_value_array_2(ctx, v98);
                                                                    let mut v109 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                                    let mut v109 = v109.into_context_iter();
                                                                    while let Some(v110) = v109.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v127,
                                                                            imm: v128,
                                                                        } = &v110.1 {
                                                                            if let &Opcode::Iconst = v127 {
                                                                                if v2.0 == v110.0 {
                                                                                    let v1064 = constructor_umin(ctx, v2.0, v99.1, v7.1);
                                                                                    let v1065 = constructor_umin(ctx, v2.0, v99.0, v1064);
                                                                                    // Rule at src/opts/cprop.isle line 231.
                                                                                    returns.extend(Some(v1065));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let v99 = C::unpack_value_array_2(ctx, v98);
                                                if v7.1 == v99.0 {
                                                    let v330 = constructor_umin(ctx, v2.0, v99.0, v99.1);
                                                    // Rule at src/opts/arithmetic.isle line 453.
                                                    returns.extend(Some(v330));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.1 == v99.1 {
                                                    let v331 = constructor_umin(ctx, v2.0, v99.1, v99.0);
                                                    // Rule at src/opts/arithmetic.isle line 454.
                                                    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 v133,
                                                        args: ref v134,
                                                    } = &v11.1 {
                                                        match v133 {
                                                            &Opcode::Smin => {
                                                                if v2.0 == v11.0 {
                                                                    let v99 = C::unpack_value_array_2(ctx, v98);
                                                                    let v135 = C::unpack_value_array_2(ctx, v134);
                                                                    if v99.0 == v135.0 {
                                                                        if v99.1 == v135.1 {
                                                                            let v330 = constructor_umin(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/arithmetic.isle line 497.
                                                                            returns.extend(Some(v330));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v99.0 == v135.1 {
                                                                        if v99.1 == v135.0 {
                                                                            let v330 = constructor_umin(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/arithmetic.isle line 498.
                                                                            returns.extend(Some(v330));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Umin => {
                                                                if v2.0 == v11.0 {
                                                                    let v99 = C::unpack_value_array_2(ctx, v98);
                                                                    let v135 = C::unpack_value_array_2(ctx, v134);
                                                                    if v99.0 == v135.0 {
                                                                        if v99.1 == v135.1 {
                                                                            let v330 = constructor_umin(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/arithmetic.isle line 499.
                                                                            returns.extend(Some(v330));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v99.0 == v135.1 {
                                                                        if v99.1 == v135.0 {
                                                                            let v330 = constructor_umin(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/arithmetic.isle line 500.
                                                                            returns.extend(Some(v330));
                                                                            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 v133,
                                                        args: ref v134,
                                                    } = &v11.1 {
                                                        match v133 {
                                                            &Opcode::Smin => {
                                                                if v2.0 == v11.0 {
                                                                    let v99 = C::unpack_value_array_2(ctx, v98);
                                                                    let v135 = C::unpack_value_array_2(ctx, v134);
                                                                    if v99.0 == v135.0 {
                                                                        if v99.1 == v135.1 {
                                                                            let v326 = constructor_smin(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/arithmetic.isle line 507.
                                                                            returns.extend(Some(v326));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v99.0 == v135.1 {
                                                                        if v99.1 == v135.0 {
                                                                            let v326 = constructor_smin(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/arithmetic.isle line 508.
                                                                            returns.extend(Some(v326));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Umin => {
                                                                if v2.0 == v11.0 {
                                                                    let v99 = C::unpack_value_array_2(ctx, v98);
                                                                    let v135 = C::unpack_value_array_2(ctx, v134);
                                                                    if v99.0 == v135.0 {
                                                                        if v99.1 == v135.1 {
                                                                            let v330 = constructor_umin(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/arithmetic.isle line 509.
                                                                            returns.extend(Some(v330));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v99.0 == v135.1 {
                                                                        if v99.1 == v135.0 {
                                                                            let v330 = constructor_umin(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/arithmetic.isle line 510.
                                                                            returns.extend(Some(v330));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                    }
                                                }
                                                let v99 = C::unpack_value_array_2(ctx, v98);
                                                if v7.1 == v99.0 {
                                                    // Rule at src/opts/arithmetic.isle line 464.
                                                    returns.extend(Some(v99.0));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.1 == v99.1 {
                                                    // Rule at src/opts/arithmetic.isle line 463.
                                                    returns.extend(Some(v99.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 v1849 = C::lane_type(ctx, v2.0);
                                                            let v2013 = constructor_umin(ctx, v1849, v30, v27);
                                                            let v2014 = constructor_splat(ctx, v2.0, v2013);
                                                            // Rule at src/opts/vector.isle line 57.
                                                            returns.extend(Some(v2014));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v22,
                                    imm: v23,
                                } => {
                                    if let &Opcode::Iconst = v22 {
                                        let v334 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v335) = v334 {
                                            if v19.0 == v335 {
                                                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 v988 = C::imm64_umin(ctx, v335, v23, v15);
                                                                let v989 = constructor_iconst(ctx, v335, v988);
                                                                let v990 = C::subsume(ctx, v989);
                                                                // Rule at src/opts/cprop.isle line 103.
                                                                returns.extend(Some(v990));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        if v2.0 == v19.0 {
                                            let v1027 = constructor_umin(ctx, v2.0, v7.1, v7.0);
                                            // Rule at src/opts/cprop.isle line 169.
                                            returns.extend(Some(v1027));
                                            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 v133,
                                args: ref v134,
                            } = &v11.1 {
                                match v133 {
                                    &Opcode::Umin => {
                                        if v2.0 == v11.0 {
                                            let v135 = C::unpack_value_array_2(ctx, v134);
                                            if v7.0 == v135.0 {
                                                let v332 = constructor_umin(ctx, v2.0, v7.0, v135.1);
                                                // Rule at src/opts/arithmetic.isle line 455.
                                                returns.extend(Some(v332));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            if v7.0 == v135.1 {
                                                let v333 = constructor_umin(ctx, v2.0, v7.0, v135.0);
                                                // Rule at src/opts/arithmetic.isle line 456.
                                                returns.extend(Some(v333));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                    &Opcode::Umax => {
                                        if v2.0 == v11.0 {
                                            let v135 = C::unpack_value_array_2(ctx, v134);
                                            if v7.0 == v135.0 {
                                                // Rule at src/opts/arithmetic.isle line 466.
                                                returns.extend(Some(v7.0));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            if v7.0 == v135.1 {
                                                // Rule at src/opts/arithmetic.isle line 465.
                                                returns.extend(Some(v7.0));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                        }
                        if v7.0 == v7.1 {
                            // Rule at src/opts/arithmetic.isle line 433.
                            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 v97,
                                    args: ref v98,
                                } => {
                                    match v97 {
                                        &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 v133,
                                                        args: ref v134,
                                                    } = &v11.1 {
                                                        match v133 {
                                                            &Opcode::Smax => {
                                                                if v2.0 == v11.0 {
                                                                    let v99 = C::unpack_value_array_2(ctx, v98);
                                                                    let v135 = C::unpack_value_array_2(ctx, v134);
                                                                    if v99.0 == v135.0 {
                                                                        if v99.1 == v135.1 {
                                                                            let v318 = constructor_smax(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/arithmetic.isle line 523.
                                                                            returns.extend(Some(v318));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v99.0 == v135.1 {
                                                                        if v99.1 == v135.0 {
                                                                            let v318 = constructor_smax(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/arithmetic.isle line 524.
                                                                            returns.extend(Some(v318));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Umax => {
                                                                if v2.0 == v11.0 {
                                                                    let v99 = C::unpack_value_array_2(ctx, v98);
                                                                    let v135 = C::unpack_value_array_2(ctx, v134);
                                                                    if v99.0 == v135.0 {
                                                                        if v99.1 == v135.1 {
                                                                            let v322 = constructor_umax(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/arithmetic.isle line 525.
                                                                            returns.extend(Some(v322));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v99.0 == v135.1 {
                                                                        if v99.1 == v135.0 {
                                                                            let v322 = constructor_umax(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/arithmetic.isle line 526.
                                                                            returns.extend(Some(v322));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                    }
                                                }
                                                let v99 = C::unpack_value_array_2(ctx, v98);
                                                if v7.1 == v99.0 {
                                                    // Rule at src/opts/arithmetic.isle line 468.
                                                    returns.extend(Some(v99.0));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.1 == v99.1 {
                                                    // Rule at src/opts/arithmetic.isle line 467.
                                                    returns.extend(Some(v99.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 v133,
                                                        args: ref v134,
                                                    } = &v11.1 {
                                                        match v133 {
                                                            &Opcode::Smax => {
                                                                if v2.0 == v11.0 {
                                                                    let v99 = C::unpack_value_array_2(ctx, v98);
                                                                    let v135 = C::unpack_value_array_2(ctx, v134);
                                                                    if v99.0 == v135.0 {
                                                                        if v99.1 == v135.1 {
                                                                            let v318 = constructor_smax(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/arithmetic.isle line 533.
                                                                            returns.extend(Some(v318));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v99.0 == v135.1 {
                                                                        if v99.1 == v135.0 {
                                                                            let v318 = constructor_smax(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/arithmetic.isle line 534.
                                                                            returns.extend(Some(v318));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Umax => {
                                                                if v2.0 == v11.0 {
                                                                    let v99 = C::unpack_value_array_2(ctx, v98);
                                                                    let v135 = C::unpack_value_array_2(ctx, v134);
                                                                    if v99.0 == v135.0 {
                                                                        if v99.1 == v135.1 {
                                                                            let v318 = constructor_smax(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/arithmetic.isle line 535.
                                                                            returns.extend(Some(v318));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v99.0 == v135.1 {
                                                                        if v99.1 == v135.0 {
                                                                            let v318 = constructor_smax(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/arithmetic.isle line 536.
                                                                            returns.extend(Some(v318));
                                                                            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 v133,
                                                            args: ref v134,
                                                        } => {
                                                            match v133 {
                                                                &Opcode::Smin => {
                                                                    if v2.0 == v11.0 {
                                                                        let v99 = C::unpack_value_array_2(ctx, v98);
                                                                        let v135 = C::unpack_value_array_2(ctx, v134);
                                                                        if v99.0 == v135.0 {
                                                                            if v99.1 == v135.1 {
                                                                                let v318 = constructor_smax(ctx, v2.0, v99.0, v99.1);
                                                                                // Rule at src/opts/arithmetic.isle line 518.
                                                                                returns.extend(Some(v318));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                        if v99.0 == v135.1 {
                                                                            if v99.1 == v135.0 {
                                                                                let v318 = constructor_smax(ctx, v2.0, v99.0, v99.1);
                                                                                // Rule at src/opts/arithmetic.isle line 519.
                                                                                returns.extend(Some(v318));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Umin => {
                                                                    if v2.0 == v11.0 {
                                                                        let v99 = C::unpack_value_array_2(ctx, v98);
                                                                        let v135 = C::unpack_value_array_2(ctx, v134);
                                                                        if v99.0 == v135.0 {
                                                                            if v99.1 == v135.1 {
                                                                                let v318 = constructor_smax(ctx, v2.0, v99.0, v99.1);
                                                                                // Rule at src/opts/arithmetic.isle line 520.
                                                                                returns.extend(Some(v318));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                        if v99.0 == v135.1 {
                                                                            if v99.1 == v135.0 {
                                                                                let v318 = constructor_smax(ctx, v2.0, v99.0, v99.1);
                                                                                // Rule at src/opts/arithmetic.isle line 521.
                                                                                returns.extend(Some(v318));
                                                                                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 v99 = C::unpack_value_array_2(ctx, v98);
                                                                    let mut v109 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                                    let mut v109 = v109.into_context_iter();
                                                                    while let Some(v110) = v109.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v127,
                                                                            imm: v128,
                                                                        } = &v110.1 {
                                                                            if let &Opcode::Iconst = v127 {
                                                                                if v2.0 == v110.0 {
                                                                                    let v1070 = constructor_smax(ctx, v2.0, v99.1, v7.1);
                                                                                    let v1071 = constructor_smax(ctx, v2.0, v99.0, v1070);
                                                                                    // Rule at src/opts/cprop.isle line 240.
                                                                                    returns.extend(Some(v1071));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let v99 = C::unpack_value_array_2(ctx, v98);
                                                if v7.1 == v99.0 {
                                                    let v318 = constructor_smax(ctx, v2.0, v99.0, v99.1);
                                                    // Rule at src/opts/arithmetic.isle line 439.
                                                    returns.extend(Some(v318));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.1 == v99.1 {
                                                    let v319 = constructor_smax(ctx, v2.0, v99.1, v99.0);
                                                    // Rule at src/opts/arithmetic.isle line 440.
                                                    returns.extend(Some(v319));
                                                    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 v133,
                                                        args: ref v134,
                                                    } = &v11.1 {
                                                        match v133 {
                                                            &Opcode::Smin => {
                                                                if v2.0 == v11.0 {
                                                                    let v99 = C::unpack_value_array_2(ctx, v98);
                                                                    let v135 = C::unpack_value_array_2(ctx, v134);
                                                                    if v99.0 == v135.0 {
                                                                        if v99.1 == v135.1 {
                                                                            let v322 = constructor_umax(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/arithmetic.isle line 528.
                                                                            returns.extend(Some(v322));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v99.0 == v135.1 {
                                                                        if v99.1 == v135.0 {
                                                                            let v322 = constructor_umax(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/arithmetic.isle line 529.
                                                                            returns.extend(Some(v322));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Umin => {
                                                                if v2.0 == v11.0 {
                                                                    let v99 = C::unpack_value_array_2(ctx, v98);
                                                                    let v135 = C::unpack_value_array_2(ctx, v134);
                                                                    if v99.0 == v135.0 {
                                                                        if v99.1 == v135.1 {
                                                                            let v318 = constructor_smax(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/arithmetic.isle line 530.
                                                                            returns.extend(Some(v318));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v99.0 == v135.1 {
                                                                        if v99.1 == v135.0 {
                                                                            let v318 = constructor_smax(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/arithmetic.isle line 531.
                                                                            returns.extend(Some(v318));
                                                                            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 v1849 = C::lane_type(ctx, v2.0);
                                                            let v2015 = constructor_smax(ctx, v1849, v30, v27);
                                                            let v2016 = constructor_splat(ctx, v2.0, v2015);
                                                            // Rule at src/opts/vector.isle line 60.
                                                            returns.extend(Some(v2016));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v22,
                                    imm: v23,
                                } => {
                                    if let &Opcode::Iconst = v22 {
                                        let v334 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v335) = v334 {
                                            if v19.0 == v335 {
                                                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 v997 = C::imm64_smax(ctx, v335, v23, v15);
                                                                let v998 = constructor_iconst(ctx, v335, v997);
                                                                let v999 = C::subsume(ctx, v998);
                                                                // Rule at src/opts/cprop.isle line 118.
                                                                returns.extend(Some(v999));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        if v2.0 == v19.0 {
                                            let v1028 = constructor_smax(ctx, v2.0, v7.1, v7.0);
                                            // Rule at src/opts/cprop.isle line 170.
                                            returns.extend(Some(v1028));
                                            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 v133,
                                args: ref v134,
                            } = &v11.1 {
                                match v133 {
                                    &Opcode::Smin => {
                                        if v2.0 == v11.0 {
                                            let v135 = C::unpack_value_array_2(ctx, v134);
                                            if v7.0 == v135.0 {
                                                // Rule at src/opts/arithmetic.isle line 470.
                                                returns.extend(Some(v7.0));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            if v7.0 == v135.1 {
                                                // Rule at src/opts/arithmetic.isle line 469.
                                                returns.extend(Some(v7.0));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                    &Opcode::Smax => {
                                        if v2.0 == v11.0 {
                                            let v135 = C::unpack_value_array_2(ctx, v134);
                                            if v7.0 == v135.0 {
                                                let v320 = constructor_smax(ctx, v2.0, v7.0, v135.1);
                                                // Rule at src/opts/arithmetic.isle line 441.
                                                returns.extend(Some(v320));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            if v7.0 == v135.1 {
                                                let v321 = constructor_smax(ctx, v2.0, v7.0, v135.0);
                                                // Rule at src/opts/arithmetic.isle line 442.
                                                returns.extend(Some(v321));
                                                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::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 v97,
                                    args: ref v98,
                                } => {
                                    match v97 {
                                        &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 v133,
                                                        args: ref v134,
                                                    } = &v11.1 {
                                                        match v133 {
                                                            &Opcode::Smax => {
                                                                if v2.0 == v11.0 {
                                                                    let v99 = C::unpack_value_array_2(ctx, v98);
                                                                    let v135 = C::unpack_value_array_2(ctx, v134);
                                                                    if v99.0 == v135.0 {
                                                                        if v99.1 == v135.1 {
                                                                            let v322 = constructor_umax(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/arithmetic.isle line 543.
                                                                            returns.extend(Some(v322));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v99.0 == v135.1 {
                                                                        if v99.1 == v135.0 {
                                                                            let v322 = constructor_umax(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/arithmetic.isle line 544.
                                                                            returns.extend(Some(v322));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Umax => {
                                                                if v2.0 == v11.0 {
                                                                    let v99 = C::unpack_value_array_2(ctx, v98);
                                                                    let v135 = C::unpack_value_array_2(ctx, v134);
                                                                    if v99.0 == v135.0 {
                                                                        if v99.1 == v135.1 {
                                                                            let v322 = constructor_umax(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/arithmetic.isle line 545.
                                                                            returns.extend(Some(v322));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v99.0 == v135.1 {
                                                                        if v99.1 == v135.0 {
                                                                            let v322 = constructor_umax(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/arithmetic.isle line 546.
                                                                            returns.extend(Some(v322));
                                                                            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 v133,
                                                        args: ref v134,
                                                    } = &v11.1 {
                                                        match v133 {
                                                            &Opcode::Smax => {
                                                                if v2.0 == v11.0 {
                                                                    let v99 = C::unpack_value_array_2(ctx, v98);
                                                                    let v135 = C::unpack_value_array_2(ctx, v134);
                                                                    if v99.0 == v135.0 {
                                                                        if v99.1 == v135.1 {
                                                                            let v318 = constructor_smax(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/arithmetic.isle line 553.
                                                                            returns.extend(Some(v318));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v99.0 == v135.1 {
                                                                        if v99.1 == v135.0 {
                                                                            let v318 = constructor_smax(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/arithmetic.isle line 554.
                                                                            returns.extend(Some(v318));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Umax => {
                                                                if v2.0 == v11.0 {
                                                                    let v99 = C::unpack_value_array_2(ctx, v98);
                                                                    let v135 = C::unpack_value_array_2(ctx, v134);
                                                                    if v99.0 == v135.0 {
                                                                        if v99.1 == v135.1 {
                                                                            let v322 = constructor_umax(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/arithmetic.isle line 555.
                                                                            returns.extend(Some(v322));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v99.0 == v135.1 {
                                                                        if v99.1 == v135.0 {
                                                                            let v322 = constructor_umax(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/arithmetic.isle line 556.
                                                                            returns.extend(Some(v322));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                    }
                                                }
                                                let v99 = C::unpack_value_array_2(ctx, v98);
                                                if v7.1 == v99.0 {
                                                    // Rule at src/opts/arithmetic.isle line 472.
                                                    returns.extend(Some(v99.0));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.1 == v99.1 {
                                                    // Rule at src/opts/arithmetic.isle line 471.
                                                    returns.extend(Some(v99.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 v133,
                                                        args: ref v134,
                                                    } = &v11.1 {
                                                        match v133 {
                                                            &Opcode::Smin => {
                                                                if v2.0 == v11.0 {
                                                                    let v99 = C::unpack_value_array_2(ctx, v98);
                                                                    let v135 = C::unpack_value_array_2(ctx, v134);
                                                                    if v99.0 == v135.0 {
                                                                        if v99.1 == v135.1 {
                                                                            let v322 = constructor_umax(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/arithmetic.isle line 538.
                                                                            returns.extend(Some(v322));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v99.0 == v135.1 {
                                                                        if v99.1 == v135.0 {
                                                                            let v322 = constructor_umax(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/arithmetic.isle line 539.
                                                                            returns.extend(Some(v322));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Umin => {
                                                                if v2.0 == v11.0 {
                                                                    let v99 = C::unpack_value_array_2(ctx, v98);
                                                                    let v135 = C::unpack_value_array_2(ctx, v134);
                                                                    if v99.0 == v135.0 {
                                                                        if v99.1 == v135.1 {
                                                                            let v318 = constructor_smax(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/arithmetic.isle line 540.
                                                                            returns.extend(Some(v318));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v99.0 == v135.1 {
                                                                        if v99.1 == v135.0 {
                                                                            let v318 = constructor_smax(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/arithmetic.isle line 541.
                                                                            returns.extend(Some(v318));
                                                                            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 v133,
                                                            args: ref v134,
                                                        } => {
                                                            match v133 {
                                                                &Opcode::Smin => {
                                                                    if v2.0 == v11.0 {
                                                                        let v99 = C::unpack_value_array_2(ctx, v98);
                                                                        let v135 = C::unpack_value_array_2(ctx, v134);
                                                                        if v99.0 == v135.0 {
                                                                            if v99.1 == v135.1 {
                                                                                let v322 = constructor_umax(ctx, v2.0, v99.0, v99.1);
                                                                                // Rule at src/opts/arithmetic.isle line 548.
                                                                                returns.extend(Some(v322));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                        if v99.0 == v135.1 {
                                                                            if v99.1 == v135.0 {
                                                                                let v322 = constructor_umax(ctx, v2.0, v99.0, v99.1);
                                                                                // Rule at src/opts/arithmetic.isle line 549.
                                                                                returns.extend(Some(v322));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Umin => {
                                                                    if v2.0 == v11.0 {
                                                                        let v99 = C::unpack_value_array_2(ctx, v98);
                                                                        let v135 = C::unpack_value_array_2(ctx, v134);
                                                                        if v99.0 == v135.0 {
                                                                            if v99.1 == v135.1 {
                                                                                let v322 = constructor_umax(ctx, v2.0, v99.0, v99.1);
                                                                                // Rule at src/opts/arithmetic.isle line 550.
                                                                                returns.extend(Some(v322));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                        if v99.0 == v135.1 {
                                                                            if v99.1 == v135.0 {
                                                                                let v322 = constructor_umax(ctx, v2.0, v99.0, v99.1);
                                                                                // Rule at src/opts/arithmetic.isle line 551.
                                                                                returns.extend(Some(v322));
                                                                                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 v99 = C::unpack_value_array_2(ctx, v98);
                                                                    let mut v109 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                                    let mut v109 = v109.into_context_iter();
                                                                    while let Some(v110) = v109.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v127,
                                                                            imm: v128,
                                                                        } = &v110.1 {
                                                                            if let &Opcode::Iconst = v127 {
                                                                                if v2.0 == v110.0 {
                                                                                    let v1066 = constructor_umax(ctx, v2.0, v99.1, v7.1);
                                                                                    let v1067 = constructor_umax(ctx, v2.0, v99.0, v1066);
                                                                                    // Rule at src/opts/cprop.isle line 234.
                                                                                    returns.extend(Some(v1067));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let v99 = C::unpack_value_array_2(ctx, v98);
                                                if v7.1 == v99.0 {
                                                    let v322 = constructor_umax(ctx, v2.0, v99.0, v99.1);
                                                    // Rule at src/opts/arithmetic.isle line 443.
                                                    returns.extend(Some(v322));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.1 == v99.1 {
                                                    let v323 = constructor_umax(ctx, v2.0, v99.1, v99.0);
                                                    // Rule at src/opts/arithmetic.isle line 444.
                                                    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 v1849 = C::lane_type(ctx, v2.0);
                                                            let v2017 = constructor_umax(ctx, v1849, v30, v27);
                                                            let v2018 = constructor_splat(ctx, v2.0, v2017);
                                                            // Rule at src/opts/vector.isle line 63.
                                                            returns.extend(Some(v2018));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v22,
                                    imm: v23,
                                } => {
                                    if let &Opcode::Iconst = v22 {
                                        let v334 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v335) = v334 {
                                            if v19.0 == v335 {
                                                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 v991 = C::imm64_umax(ctx, v335, v23, v15);
                                                                let v992 = constructor_iconst(ctx, v335, v991);
                                                                let v993 = C::subsume(ctx, v992);
                                                                // Rule at src/opts/cprop.isle line 108.
                                                                returns.extend(Some(v993));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        if v2.0 == v19.0 {
                                            let v1029 = constructor_umax(ctx, v2.0, v7.1, v7.0);
                                            // Rule at src/opts/cprop.isle line 171.
                                            returns.extend(Some(v1029));
                                            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 v133,
                                args: ref v134,
                            } = &v11.1 {
                                match v133 {
                                    &Opcode::Umin => {
                                        if v2.0 == v11.0 {
                                            let v135 = C::unpack_value_array_2(ctx, v134);
                                            if v7.0 == v135.0 {
                                                // Rule at src/opts/arithmetic.isle line 474.
                                                returns.extend(Some(v7.0));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            if v7.0 == v135.1 {
                                                // Rule at src/opts/arithmetic.isle line 473.
                                                returns.extend(Some(v7.0));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                    &Opcode::Umax => {
                                        if v2.0 == v11.0 {
                                            let v135 = C::unpack_value_array_2(ctx, v134);
                                            if v7.0 == v135.0 {
                                                let v324 = constructor_umax(ctx, v2.0, v7.0, v135.1);
                                                // Rule at src/opts/arithmetic.isle line 445.
                                                returns.extend(Some(v324));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            if v7.0 == v135.1 {
                                                let v325 = constructor_umax(ctx, v2.0, v7.0, v135.0);
                                                // Rule at src/opts/arithmetic.isle line 446.
                                                returns.extend(Some(v325));
                                                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::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 v133,
                                    args: ref v134,
                                } => {
                                    match v133 {
                                        &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 v97,
                                                        args: ref v98,
                                                    } = &v19.1 {
                                                        if let &Opcode::Smax = v97 {
                                                            if v2.0 == v19.0 {
                                                                let v99 = C::unpack_value_array_2(ctx, v98);
                                                                let v135 = C::unpack_value_array_2(ctx, v134);
                                                                if v99.0 == v135.0 {
                                                                    if v99.1 == v135.1 {
                                                                        let v250 = constructor_iadd(ctx, v2.0, v99.0, v99.1);
                                                                        // Rule at src/opts/arithmetic.isle line 345.
                                                                        returns.extend(Some(v250));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        let v251 = constructor_iadd(ctx, v2.0, v99.1, v99.0);
                                                                        // Rule at src/opts/arithmetic.isle line 351.
                                                                        returns.extend(Some(v251));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                                if v99.0 == v135.1 {
                                                                    if v99.1 == v135.0 {
                                                                        let v251 = constructor_iadd(ctx, v2.0, v99.1, v99.0);
                                                                        // Rule at src/opts/arithmetic.isle line 347.
                                                                        returns.extend(Some(v251));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        let v250 = constructor_iadd(ctx, v2.0, v99.0, v99.1);
                                                                        // Rule at src/opts/arithmetic.isle line 349.
                                                                        returns.extend(Some(v250));
                                                                        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 v97,
                                                        args: ref v98,
                                                    } = &v19.1 {
                                                        if let &Opcode::Umax = v97 {
                                                            if v2.0 == v19.0 {
                                                                let v99 = C::unpack_value_array_2(ctx, v98);
                                                                let v135 = C::unpack_value_array_2(ctx, v134);
                                                                if v99.0 == v135.0 {
                                                                    if v99.1 == v135.1 {
                                                                        let v250 = constructor_iadd(ctx, v2.0, v99.0, v99.1);
                                                                        // Rule at src/opts/arithmetic.isle line 335.
                                                                        returns.extend(Some(v250));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        let v251 = constructor_iadd(ctx, v2.0, v99.1, v99.0);
                                                                        // Rule at src/opts/arithmetic.isle line 341.
                                                                        returns.extend(Some(v251));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                                if v99.0 == v135.1 {
                                                                    if v99.1 == v135.0 {
                                                                        let v251 = constructor_iadd(ctx, v2.0, v99.1, v99.0);
                                                                        // Rule at src/opts/arithmetic.isle line 337.
                                                                        returns.extend(Some(v251));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        let v250 = constructor_iadd(ctx, v2.0, v99.0, v99.1);
                                                                        // Rule at src/opts/arithmetic.isle line 339.
                                                                        returns.extend(Some(v250));
                                                                        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 v97,
                                                        args: ref v98,
                                                    } = &v19.1 {
                                                        if let &Opcode::Smin = v97 {
                                                            if v2.0 == v19.0 {
                                                                let v99 = C::unpack_value_array_2(ctx, v98);
                                                                let v135 = C::unpack_value_array_2(ctx, v134);
                                                                if v99.0 == v135.0 {
                                                                    if v99.1 == v135.1 {
                                                                        let v250 = constructor_iadd(ctx, v2.0, v99.0, v99.1);
                                                                        // Rule at src/opts/arithmetic.isle line 344.
                                                                        returns.extend(Some(v250));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        let v251 = constructor_iadd(ctx, v2.0, v99.1, v99.0);
                                                                        // Rule at src/opts/arithmetic.isle line 350.
                                                                        returns.extend(Some(v251));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                                if v99.0 == v135.1 {
                                                                    if v99.1 == v135.0 {
                                                                        let v250 = constructor_iadd(ctx, v2.0, v99.0, v99.1);
                                                                        // Rule at src/opts/arithmetic.isle line 346.
                                                                        returns.extend(Some(v250));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        let v251 = constructor_iadd(ctx, v2.0, v99.1, v99.0);
                                                                        // Rule at src/opts/arithmetic.isle line 348.
                                                                        returns.extend(Some(v251));
                                                                        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 v97,
                                                        args: ref v98,
                                                    } = &v19.1 {
                                                        if let &Opcode::Umin = v97 {
                                                            if v2.0 == v19.0 {
                                                                let v99 = C::unpack_value_array_2(ctx, v98);
                                                                let v135 = C::unpack_value_array_2(ctx, v134);
                                                                if v99.0 == v135.0 {
                                                                    if v99.1 == v135.1 {
                                                                        let v250 = constructor_iadd(ctx, v2.0, v99.0, v99.1);
                                                                        // Rule at src/opts/arithmetic.isle line 334.
                                                                        returns.extend(Some(v250));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        let v251 = constructor_iadd(ctx, v2.0, v99.1, v99.0);
                                                                        // Rule at src/opts/arithmetic.isle line 340.
                                                                        returns.extend(Some(v251));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                                if v99.0 == v135.1 {
                                                                    if v99.1 == v135.0 {
                                                                        let v250 = constructor_iadd(ctx, v2.0, v99.0, v99.1);
                                                                        // Rule at src/opts/arithmetic.isle line 336.
                                                                        returns.extend(Some(v250));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        let v251 = constructor_iadd(ctx, v2.0, v99.1, v99.0);
                                                                        // Rule at src/opts/arithmetic.isle line 338.
                                                                        returns.extend(Some(v251));
                                                                        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 v97,
                                                            args: ref v98,
                                                        } => {
                                                            match v97 {
                                                                &Opcode::Iadd => {
                                                                    if v2.0 == v19.0 {
                                                                        let v99 = C::unpack_value_array_2(ctx, v98);
                                                                        let mut v109 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                                        let mut v109 = v109.into_context_iter();
                                                                        while let Some(v110) = v109.next(ctx) {
                                                                            if let &InstructionData::UnaryImm {
                                                                                opcode: ref v127,
                                                                                imm: v128,
                                                                            } = &v110.1 {
                                                                                if let &Opcode::Iconst = v127 {
                                                                                    let v135 = C::unpack_value_array_2(ctx, v134);
                                                                                    let mut v258 = C::inst_data_value_etor_returns::default();
                                                                                    C::inst_data_value_etor(ctx, v135.1, &mut v258);
                                                                                    let mut v258 = v258.into_context_iter();
                                                                                    while let Some(v259) = v258.next(ctx) {
                                                                                        if let &InstructionData::UnaryImm {
                                                                                            opcode: ref v1124,
                                                                                            imm: v1125,
                                                                                        } = &v259.1 {
                                                                                            if let &Opcode::Iconst = v1124 {
                                                                                                let v254 = constructor_iadd(ctx, v2.0, v99.0, v135.0);
                                                                                                let v1126 = constructor_iadd(ctx, v2.0, v99.1, v135.1);
                                                                                                let v1127 = constructor_iadd(ctx, v2.0, v254, v1126);
                                                                                                // Rule at src/opts/cprop.isle line 313.
                                                                                                returns.extend(Some(v1127));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Isub => {
                                                                    if v2.0 == v19.0 {
                                                                        let v99 = C::unpack_value_array_2(ctx, v98);
                                                                        let v135 = C::unpack_value_array_2(ctx, v134);
                                                                        if v99.1 == v135.0 {
                                                                            let v252 = constructor_iadd(ctx, v2.0, v99.0, v135.1);
                                                                            // Rule at src/opts/arithmetic.isle line 360.
                                                                            returns.extend(Some(v252));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v99.1 == v135.1 {
                                                                            let v254 = constructor_iadd(ctx, v2.0, v99.0, v135.0);
                                                                            // Rule at src/opts/arithmetic.isle line 362.
                                                                            returns.extend(Some(v254));
                                                                            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 v135 = C::unpack_value_array_2(ctx, v134);
                                                                    if v30 == v135.0 {
                                                                        // Rule at src/opts/arithmetic.isle line 297.
                                                                        returns.extend(Some(v135.1));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v30 == v135.1 {
                                                                        // Rule at src/opts/arithmetic.isle line 295.
                                                                        returns.extend(Some(v135.0));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let v135 = C::unpack_value_array_2(ctx, v134);
                                                let mut v258 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v135.1, &mut v258);
                                                let mut v258 = v258.into_context_iter();
                                                while let Some(v259) = v258.next(ctx) {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v262,
                                                        args: ref v263,
                                                    } = &v259.1 {
                                                        if let &Opcode::Isub = v262 {
                                                            if v2.0 == v259.0 {
                                                                let v264 = C::unpack_value_array_2(ctx, v263);
                                                                if v7.0 == v264.1 {
                                                                    let v267 = constructor_iadd(ctx, v2.0, v135.0, v264.0);
                                                                    // Rule at src/opts/arithmetic.isle line 370.
                                                                    returns.extend(Some(v267));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                let mut v274 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v135.0, &mut v274);
                                                let mut v274 = v274.into_context_iter();
                                                while let Some(v275) = v274.next(ctx) {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v278,
                                                        args: ref v279,
                                                    } = &v275.1 {
                                                        if let &Opcode::Isub = v278 {
                                                            if v2.0 == v275.0 {
                                                                let v280 = C::unpack_value_array_2(ctx, v279);
                                                                if v7.0 == v280.1 {
                                                                    let v283 = constructor_iadd(ctx, v2.0, v135.1, v280.0);
                                                                    // Rule at src/opts/arithmetic.isle line 372.
                                                                    returns.extend(Some(v283));
                                                                    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 v97,
                                                        args: ref v98,
                                                    } = &v19.1 {
                                                        if let &Opcode::Iadd = v97 {
                                                            if v2.0 == v19.0 {
                                                                let v99 = C::unpack_value_array_2(ctx, v98);
                                                                let v135 = C::unpack_value_array_2(ctx, v134);
                                                                if v99.0 == v135.1 {
                                                                    let v253 = constructor_iadd(ctx, v2.0, v135.0, v99.1);
                                                                    // Rule at src/opts/arithmetic.isle line 361.
                                                                    returns.extend(Some(v253));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v99.1 == v135.1 {
                                                                    let v255 = constructor_iadd(ctx, v2.0, v135.0, v99.0);
                                                                    // Rule at src/opts/arithmetic.isle line 363.
                                                                    returns.extend(Some(v255));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                let v135 = C::unpack_value_array_2(ctx, v134);
                                                if v7.0 == v135.1 {
                                                    // Rule at src/opts/arithmetic.isle line 239.
                                                    returns.extend(Some(v135.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 v97,
                                                        args: ref v98,
                                                    } = &v19.1 {
                                                        match v97 {
                                                            &Opcode::Bor => {
                                                                if v2.0 == v19.0 {
                                                                    let v99 = C::unpack_value_array_2(ctx, v98);
                                                                    let v135 = C::unpack_value_array_2(ctx, v134);
                                                                    if v99.0 == v135.0 {
                                                                        if v99.1 == v135.1 {
                                                                            let v250 = constructor_iadd(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/bitops.isle line 208.
                                                                            returns.extend(Some(v250));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Bxor => {
                                                                if v2.0 == v19.0 {
                                                                    let v99 = C::unpack_value_array_2(ctx, v98);
                                                                    let v135 = C::unpack_value_array_2(ctx, v134);
                                                                    if v99.0 == v135.0 {
                                                                        if v99.1 == v135.1 {
                                                                            let v240 = constructor_bor(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/bitops.isle line 205.
                                                                            returns.extend(Some(v240));
                                                                            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 v97,
                                                            args: ref v98,
                                                        } => {
                                                            if let &Opcode::Band = v97 {
                                                                if v2.0 == v19.0 {
                                                                    let v99 = C::unpack_value_array_2(ctx, v98);
                                                                    let v135 = C::unpack_value_array_2(ctx, v134);
                                                                    if v99.0 == v135.0 {
                                                                        if v99.1 == v135.1 {
                                                                            let v250 = constructor_iadd(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/bitops.isle line 209.
                                                                            returns.extend(Some(v250));
                                                                            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 v135 = C::unpack_value_array_2(ctx, v134);
                                                                    if v30 == v135.0 {
                                                                        let v635 = constructor_bnot(ctx, v2.0, v30);
                                                                        let v667 = constructor_band(ctx, v2.0, v135.1, v635);
                                                                        // Rule at src/opts/bitops.isle line 245.
                                                                        returns.extend(Some(v667));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v30 == v135.1 {
                                                                        let v635 = constructor_bnot(ctx, v2.0, v30);
                                                                        let v665 = constructor_band(ctx, v2.0, v135.0, v635);
                                                                        // Rule at src/opts/bitops.isle line 241.
                                                                        returns.extend(Some(v665));
                                                                        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 v97,
                                                        args: ref v98,
                                                    } = &v19.1 {
                                                        if let &Opcode::Band = v97 {
                                                            if v2.0 == v19.0 {
                                                                let v99 = C::unpack_value_array_2(ctx, v98);
                                                                let v135 = C::unpack_value_array_2(ctx, v134);
                                                                if v99.0 == v135.0 {
                                                                    if v99.1 == v135.1 {
                                                                        let v240 = constructor_bor(ctx, v2.0, v99.0, v99.1);
                                                                        // Rule at src/opts/bitops.isle line 204.
                                                                        returns.extend(Some(v240));
                                                                        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 v97,
                                                        args: ref v98,
                                                    } = &v19.1 {
                                                        if let &Opcode::Ishl = v97 {
                                                            if v2.0 == v19.0 {
                                                                let v99 = C::unpack_value_array_2(ctx, v98);
                                                                let v135 = C::unpack_value_array_2(ctx, v134);
                                                                if v99.1 == v135.1 {
                                                                    let v254 = constructor_iadd(ctx, v2.0, v99.0, v135.0);
                                                                    let v1906 = constructor_ishl(ctx, v2.0, v254, v99.1);
                                                                    // Rule at src/opts/shifts.isle line 314.
                                                                    returns.extend(Some(v1906));
                                                                    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 v1849 = C::lane_type(ctx, v2.0);
                                                                let v1995 = constructor_iadd(ctx, v1849, v30, v27);
                                                                let v1996 = constructor_splat(ctx, v2.0, v1995);
                                                                // Rule at src/opts/vector.isle line 30.
                                                                returns.extend(Some(v1996));
                                                                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 v97,
                                                        args: ref v98,
                                                    } = &v19.1 {
                                                        match v97 {
                                                            &Opcode::Iadd => {
                                                                if v2.0 == v19.0 {
                                                                    let v99 = C::unpack_value_array_2(ctx, v98);
                                                                    if v27 == v99.0 {
                                                                        // Rule at src/opts/arithmetic.isle line 296.
                                                                        returns.extend(Some(v99.1));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v27 == v99.1 {
                                                                        // Rule at src/opts/arithmetic.isle line 294.
                                                                        returns.extend(Some(v99.0));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Bor => {
                                                                if v2.0 == v19.0 {
                                                                    let v99 = C::unpack_value_array_2(ctx, v98);
                                                                    if v27 == v99.0 {
                                                                        let v633 = constructor_bnot(ctx, v2.0, v99.0);
                                                                        let v666 = constructor_band(ctx, v2.0, v99.1, v633);
                                                                        // Rule at src/opts/bitops.isle line 243.
                                                                        returns.extend(Some(v666));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v27 == v99.1 {
                                                                        let v663 = constructor_bnot(ctx, v2.0, v99.1);
                                                                        let v664 = constructor_band(ctx, v2.0, v99.0, v663);
                                                                        // Rule at src/opts/bitops.isle line 239.
                                                                        returns.extend(Some(v664));
                                                                        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 v244 = constructor_iconst_s(ctx, v2.0, -1_i64);
                                                    // Rule at src/opts/arithmetic.isle line 319.
                                                    returns.extend(Some(v244));
                                                    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 v97,
                                                        args: ref v98,
                                                    } => {
                                                        match v97 {
                                                            &Opcode::Iadd => {
                                                                if v2.0 == v19.0 {
                                                                    let v99 = C::unpack_value_array_2(ctx, v98);
                                                                    let mut v109 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                                    let mut v109 = v109.into_context_iter();
                                                                    while let Some(v110) = v109.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v127,
                                                                            imm: v128,
                                                                        } = &v110.1 {
                                                                            if let &Opcode::Iconst = v127 {
                                                                                if v2.0 == v110.0 {
                                                                                    let v1032 = constructor_iadd(ctx, v2.0, v99.1, v7.1);
                                                                                    let v1033 = constructor_iadd(ctx, v2.0, v99.0, v1032);
                                                                                    // Rule at src/opts/cprop.isle line 182.
                                                                                    returns.extend(Some(v1033));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Isub => {
                                                                if v2.0 == v19.0 {
                                                                    let v99 = C::unpack_value_array_2(ctx, v98);
                                                                    let mut v102 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v99.0, &mut v102);
                                                                    let mut v102 = v102.into_context_iter();
                                                                    while let Some(v103) = v102.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v1037,
                                                                            imm: v1038,
                                                                        } = &v103.1 {
                                                                            if let &Opcode::Iconst = v1037 {
                                                                                if v2.0 == v103.0 {
                                                                                    let v1046 = C::imm64_add(ctx, v2.0, v1038, v15);
                                                                                    let v1047 = constructor_iconst(ctx, v2.0, v1046);
                                                                                    let v1048 = constructor_isub(ctx, v2.0, v1047, v99.1);
                                                                                    // Rule at src/opts/cprop.isle line 208.
                                                                                    returns.extend(Some(v1048));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    let mut v109 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                                    let mut v109 = v109.into_context_iter();
                                                                    while let Some(v110) = v109.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v127,
                                                                            imm: v128,
                                                                        } = &v110.1 {
                                                                            if let &Opcode::Iconst = v127 {
                                                                                if v2.0 == v110.0 {
                                                                                    let v1042 = C::imm64_sub(ctx, v2.0, v15, v128);
                                                                                    let v1043 = constructor_iconst(ctx, v2.0, v1042);
                                                                                    let v1045 = constructor_iadd(ctx, v2.0, v99.0, v1043);
                                                                                    // Rule at src/opts/cprop.isle line 204.
                                                                                    returns.extend(Some(v1045));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Bor => {
                                                                if v2.0 == v19.0 {
                                                                    let v99 = C::unpack_value_array_2(ctx, v98);
                                                                    let mut v109 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                                    let mut v109 = v109.into_context_iter();
                                                                    while let Some(v110) = v109.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v127,
                                                                            imm: v128,
                                                                        } = &v110.1 {
                                                                            if let &Opcode::Iconst = v127 {
                                                                                if v2.0 == v110.0 {
                                                                                    let v129 = C::imm64_neg(ctx, v2.0, v128);
                                                                                    if v15 == v129 {
                                                                                        let v130 = C::imm64_not(ctx, v2.0, v128);
                                                                                        let v131 = constructor_iconst(ctx, v2.0, v130);
                                                                                        let v132 = constructor_band(ctx, v2.0, v99.0, v131);
                                                                                        // Rule at src/opts/arithmetic.isle line 225.
                                                                                        returns.extend(Some(v132));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                    }
                                                    &InstructionData::Ternary {
                                                        opcode: ref v1669,
                                                        args: ref v1670,
                                                    } => {
                                                        if let &Opcode::Select = v1669 {
                                                            if v2.0 == v19.0 {
                                                                let v1671 = C::unpack_value_array_3(ctx, v1670);
                                                                let mut v1675 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v1671.1, &mut v1675);
                                                                let mut v1675 = v1675.into_context_iter();
                                                                while let Some(v1676) = v1675.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v1679,
                                                                        imm: v1680,
                                                                    } = &v1676.1 {
                                                                        if let &Opcode::Iconst = v1679 {
                                                                            if v2.0 == v1676.0 {
                                                                                let mut v1681 = C::inst_data_value_etor_returns::default();
                                                                                C::inst_data_value_etor(ctx, v1671.2, &mut v1681);
                                                                                let mut v1681 = v1681.into_context_iter();
                                                                                while let Some(v1682) = v1681.next(ctx) {
                                                                                    if let &InstructionData::UnaryImm {
                                                                                        opcode: ref v1685,
                                                                                        imm: v1686,
                                                                                    } = &v1682.1 {
                                                                                        if let &Opcode::Iconst = v1685 {
                                                                                            if v2.0 == v1682.0 {
                                                                                                let v1687 = C::imm64_add(ctx, v2.0, v1680, v15);
                                                                                                let v1688 = constructor_iconst(ctx, v2.0, v1687);
                                                                                                let v1689 = C::imm64_add(ctx, v2.0, v1686, v15);
                                                                                                let v1690 = constructor_iconst(ctx, v2.0, v1689);
                                                                                                let v1691 = constructor_select(ctx, v2.0, v1671.0, v1688, v1690);
                                                                                                // Rule at src/opts/selects.isle line 95.
                                                                                                returns.extend(Some(v1691));
                                                                                                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 v334 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v335) = v334 {
                                            if v11.0 == v335 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                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 v952 = C::imm64_add(ctx, v335, v23, v15);
                                                                let v953 = constructor_iconst(ctx, v335, v952);
                                                                let v954 = C::subsume(ctx, v953);
                                                                // Rule at src/opts/cprop.isle line 13.
                                                                returns.extend(Some(v954));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        let v1605 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 5.
                                        returns.extend(Some(v1605));
                                        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 v97,
                                    args: ref v98,
                                } => {
                                    match v97 {
                                        &Opcode::Iadd => {
                                            if v2.0 == v19.0 {
                                                let v99 = C::unpack_value_array_2(ctx, v98);
                                                let mut v102 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v99.0, &mut v102);
                                                let mut v102 = v102.into_context_iter();
                                                while let Some(v103) = v102.next(ctx) {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v284,
                                                        args: ref v285,
                                                    } = &v103.1 {
                                                        if let &Opcode::Isub = v284 {
                                                            if v2.0 == v103.0 {
                                                                let v286 = C::unpack_value_array_2(ctx, v285);
                                                                if v7.1 == v286.1 {
                                                                    let v289 = constructor_iadd(ctx, v2.0, v99.1, v286.0);
                                                                    // Rule at src/opts/arithmetic.isle line 373.
                                                                    returns.extend(Some(v289));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                let mut v109 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                let mut v109 = v109.into_context_iter();
                                                while let Some(v110) = v109.next(ctx) {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v268,
                                                        args: ref v269,
                                                    } = &v110.1 {
                                                        if let &Opcode::Isub = v268 {
                                                            if v2.0 == v110.0 {
                                                                let v270 = C::unpack_value_array_2(ctx, v269);
                                                                if v7.1 == v270.1 {
                                                                    let v273 = constructor_iadd(ctx, v2.0, v99.0, v270.0);
                                                                    // Rule at src/opts/arithmetic.isle line 371.
                                                                    returns.extend(Some(v273));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Isub => {
                                            if v2.0 == v19.0 {
                                                let v99 = C::unpack_value_array_2(ctx, v98);
                                                if v7.1 == v99.1 {
                                                    // Rule at src/opts/arithmetic.isle line 238.
                                                    returns.extend(Some(v99.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 v244 = constructor_iconst_s(ctx, v2.0, -1_i64);
                                                    // Rule at src/opts/arithmetic.isle line 318.
                                                    returns.extend(Some(v244));
                                                    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 v1019 = constructor_iadd(ctx, v2.0, v7.1, v7.0);
                                            // Rule at src/opts/cprop.isle line 146.
                                            returns.extend(Some(v1019));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        let v1605 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 3.
                                        returns.extend(Some(v1605));
                                        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 v97,
                                    args: ref v98,
                                } => {
                                    match v97 {
                                        &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 v133,
                                                            args: ref v134,
                                                        } => {
                                                            match v133 {
                                                                &Opcode::Iadd => {
                                                                    if v2.0 == v11.0 {
                                                                        let v99 = C::unpack_value_array_2(ctx, v98);
                                                                        let v135 = C::unpack_value_array_2(ctx, v134);
                                                                        if v99.0 == v135.0 {
                                                                            let v245 = constructor_isub(ctx, v2.0, v99.1, v135.1);
                                                                            // Rule at src/opts/arithmetic.isle line 322.
                                                                            returns.extend(Some(v245));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            // Rule at src/opts/arithmetic.isle line 357.
                                                                            returns.extend(Some(v245));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v99.0 == v135.1 {
                                                                            let v246 = constructor_isub(ctx, v2.0, v99.1, v135.0);
                                                                            // Rule at src/opts/arithmetic.isle line 323.
                                                                            returns.extend(Some(v246));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            // Rule at src/opts/arithmetic.isle line 356.
                                                                            returns.extend(Some(v246));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v99.1 == v135.0 {
                                                                            let v247 = constructor_isub(ctx, v2.0, v99.0, v135.1);
                                                                            // Rule at src/opts/arithmetic.isle line 324.
                                                                            returns.extend(Some(v247));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            // Rule at src/opts/arithmetic.isle line 355.
                                                                            returns.extend(Some(v247));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v99.1 == v135.1 {
                                                                            let v248 = constructor_isub(ctx, v2.0, v99.0, v135.0);
                                                                            // Rule at src/opts/arithmetic.isle line 325.
                                                                            returns.extend(Some(v248));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            // Rule at src/opts/arithmetic.isle line 354.
                                                                            returns.extend(Some(v248));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Band => {
                                                                    if v2.0 == v11.0 {
                                                                        let v99 = C::unpack_value_array_2(ctx, v98);
                                                                        let v135 = C::unpack_value_array_2(ctx, v134);
                                                                        if v99.0 == v135.0 {
                                                                            if v99.1 == v135.1 {
                                                                                let v240 = constructor_bor(ctx, v2.0, v99.0, v99.1);
                                                                                // Rule at src/opts/arithmetic.isle line 306.
                                                                                returns.extend(Some(v240));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                let v241 = constructor_bor(ctx, v2.0, v99.1, v99.0);
                                                                                // Rule at src/opts/arithmetic.isle line 309.
                                                                                returns.extend(Some(v241));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                        if v99.0 == v135.1 {
                                                                            if v99.1 == v135.0 {
                                                                                let v240 = constructor_bor(ctx, v2.0, v99.0, v99.1);
                                                                                // Rule at src/opts/arithmetic.isle line 307.
                                                                                returns.extend(Some(v240));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                let v241 = constructor_bor(ctx, v2.0, v99.1, v99.0);
                                                                                // Rule at src/opts/arithmetic.isle line 308.
                                                                                returns.extend(Some(v241));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Bor => {
                                                                    if v2.0 == v11.0 {
                                                                        let v99 = C::unpack_value_array_2(ctx, v98);
                                                                        let v135 = C::unpack_value_array_2(ctx, v134);
                                                                        if v99.0 == v135.0 {
                                                                            if v99.1 == v135.1 {
                                                                                let v138 = constructor_band(ctx, v2.0, v99.0, v99.1);
                                                                                // Rule at src/opts/arithmetic.isle line 232.
                                                                                returns.extend(Some(v138));
                                                                                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 v99 = C::unpack_value_array_2(ctx, v98);
                                                                    let mut v109 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                                    let mut v109 = v109.into_context_iter();
                                                                    while let Some(v110) = v109.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v127,
                                                                            imm: v128,
                                                                        } = &v110.1 {
                                                                            if let &Opcode::Iconst = v127 {
                                                                                if v2.0 == v110.0 {
                                                                                    let v1042 = C::imm64_sub(ctx, v2.0, v15, v128);
                                                                                    let v1043 = constructor_iconst(ctx, v2.0, v1042);
                                                                                    let v1044 = constructor_isub(ctx, v2.0, v99.0, v1043);
                                                                                    // Rule at src/opts/cprop.isle line 200.
                                                                                    returns.extend(Some(v1044));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let v99 = C::unpack_value_array_2(ctx, v98);
                                                if v7.1 == v99.0 {
                                                    // Rule at src/opts/arithmetic.isle line 242.
                                                    returns.extend(Some(v99.1));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.1 == v99.1 {
                                                    // Rule at src/opts/arithmetic.isle line 243.
                                                    returns.extend(Some(v99.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 v133,
                                                            args: ref v134,
                                                        } => {
                                                            if let &Opcode::Isub = v133 {
                                                                if v2.0 == v11.0 {
                                                                    let v99 = C::unpack_value_array_2(ctx, v98);
                                                                    let v135 = C::unpack_value_array_2(ctx, v134);
                                                                    if v99.0 == v135.0 {
                                                                        let v249 = constructor_isub(ctx, v2.0, v135.1, v99.1);
                                                                        // Rule at src/opts/arithmetic.isle line 331.
                                                                        returns.extend(Some(v249));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v99.1 == v135.1 {
                                                                        let v248 = constructor_isub(ctx, v2.0, v99.0, v135.0);
                                                                        // Rule at src/opts/arithmetic.isle line 328.
                                                                        returns.extend(Some(v248));
                                                                        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 v99 = C::unpack_value_array_2(ctx, v98);
                                                                    let mut v102 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v99.0, &mut v102);
                                                                    let mut v102 = v102.into_context_iter();
                                                                    while let Some(v103) = v102.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v1037,
                                                                            imm: v1038,
                                                                        } = &v103.1 {
                                                                            if let &Opcode::Iconst = v1037 {
                                                                                if v2.0 == v103.0 {
                                                                                    let v1039 = C::imm64_sub(ctx, v2.0, v1038, v15);
                                                                                    let v1040 = constructor_iconst(ctx, v2.0, v1039);
                                                                                    let v1041 = constructor_isub(ctx, v2.0, v1040, v99.1);
                                                                                    // Rule at src/opts/cprop.isle line 196.
                                                                                    returns.extend(Some(v1041));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    let mut v109 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                                    let mut v109 = v109.into_context_iter();
                                                                    while let Some(v110) = v109.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v127,
                                                                            imm: v128,
                                                                        } = &v110.1 {
                                                                            if let &Opcode::Iconst = v127 {
                                                                                if v2.0 == v110.0 {
                                                                                    let v1034 = C::imm64_add(ctx, v2.0, v128, v15);
                                                                                    let v1035 = constructor_iconst(ctx, v2.0, v1034);
                                                                                    let v1036 = constructor_isub(ctx, v2.0, v99.0, v1035);
                                                                                    // Rule at src/opts/cprop.isle line 192.
                                                                                    returns.extend(Some(v1036));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let v99 = C::unpack_value_array_2(ctx, v98);
                                                if v7.1 == v99.0 {
                                                    let v146 = constructor_ineg(ctx, v2.0, v99.1);
                                                    // Rule at src/opts/arithmetic.isle line 246.
                                                    returns.extend(Some(v146));
                                                    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 v133,
                                                        args: ref v134,
                                                    } = &v11.1 {
                                                        if let &Opcode::Band = v133 {
                                                            if v2.0 == v11.0 {
                                                                let v99 = C::unpack_value_array_2(ctx, v98);
                                                                let v135 = C::unpack_value_array_2(ctx, v134);
                                                                if v99.0 == v135.0 {
                                                                    let mut v109 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                                    let mut v109 = v109.into_context_iter();
                                                                    while let Some(v110) = v109.next(ctx) {
                                                                        if let &InstructionData::Unary {
                                                                            opcode: ref v113,
                                                                            arg: v114,
                                                                        } = &v110.1 {
                                                                            if let &Opcode::Bnot = v113 {
                                                                                if v2.0 == v110.0 {
                                                                                    if v114 == v135.1 {
                                                                                        let v868 = constructor_bxor(ctx, v2.0, v99.0, v114);
                                                                                        let v869 = constructor_isub(ctx, v2.0, v868, v114);
                                                                                        // Rule at src/opts/bitops.isle line 538.
                                                                                        returns.extend(Some(v869));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    let mut v258 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v135.1, &mut v258);
                                                                    let mut v258 = v258.into_context_iter();
                                                                    while let Some(v259) = v258.next(ctx) {
                                                                        if let &InstructionData::Unary {
                                                                            opcode: ref v627,
                                                                            arg: v628,
                                                                        } = &v259.1 {
                                                                            if let &Opcode::Bnot = v627 {
                                                                                if v99.1 == v628 {
                                                                                    if v2.0 == v259.0 {
                                                                                        let v238 = constructor_bxor(ctx, v2.0, v99.0, v99.1);
                                                                                        let v872 = constructor_isub(ctx, v2.0, v99.1, v238);
                                                                                        // Rule at src/opts/bitops.isle line 542.
                                                                                        returns.extend(Some(v872));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                if v99.0 == v135.1 {
                                                                    let mut v109 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                                    let mut v109 = v109.into_context_iter();
                                                                    while let Some(v110) = v109.next(ctx) {
                                                                        if let &InstructionData::Unary {
                                                                            opcode: ref v113,
                                                                            arg: v114,
                                                                        } = &v110.1 {
                                                                            if let &Opcode::Bnot = v113 {
                                                                                if v114 == v135.0 {
                                                                                    if v2.0 == v110.0 {
                                                                                        let v868 = constructor_bxor(ctx, v2.0, v99.0, v114);
                                                                                        let v869 = constructor_isub(ctx, v2.0, v868, v114);
                                                                                        // Rule at src/opts/bitops.isle line 539.
                                                                                        returns.extend(Some(v869));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    let mut v274 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v135.0, &mut v274);
                                                                    let mut v274 = v274.into_context_iter();
                                                                    while let Some(v275) = v274.next(ctx) {
                                                                        if let &InstructionData::Unary {
                                                                            opcode: ref v630,
                                                                            arg: v631,
                                                                        } = &v275.1 {
                                                                            if let &Opcode::Bnot = v630 {
                                                                                if v99.1 == v631 {
                                                                                    if v2.0 == v275.0 {
                                                                                        let v238 = constructor_bxor(ctx, v2.0, v99.0, v99.1);
                                                                                        let v872 = constructor_isub(ctx, v2.0, v99.1, v238);
                                                                                        // Rule at src/opts/bitops.isle line 543.
                                                                                        returns.extend(Some(v872));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                if v99.1 == v135.0 {
                                                                    let mut v102 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v99.0, &mut v102);
                                                                    let mut v102 = v102.into_context_iter();
                                                                    while let Some(v103) = v102.next(ctx) {
                                                                        if let &InstructionData::Unary {
                                                                            opcode: ref v106,
                                                                            arg: v107,
                                                                        } = &v103.1 {
                                                                            if let &Opcode::Bnot = v106 {
                                                                                if v107 == v135.1 {
                                                                                    if v2.0 == v103.0 {
                                                                                        let v870 = constructor_bxor(ctx, v2.0, v99.1, v107);
                                                                                        let v871 = constructor_isub(ctx, v2.0, v870, v107);
                                                                                        // Rule at src/opts/bitops.isle line 540.
                                                                                        returns.extend(Some(v871));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    let mut v258 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v135.1, &mut v258);
                                                                    let mut v258 = v258.into_context_iter();
                                                                    while let Some(v259) = v258.next(ctx) {
                                                                        if let &InstructionData::Unary {
                                                                            opcode: ref v627,
                                                                            arg: v628,
                                                                        } = &v259.1 {
                                                                            if let &Opcode::Bnot = v627 {
                                                                                if v99.0 == v628 {
                                                                                    if v2.0 == v259.0 {
                                                                                        let v239 = constructor_bxor(ctx, v2.0, v99.1, v99.0);
                                                                                        let v873 = constructor_isub(ctx, v2.0, v99.0, v239);
                                                                                        // Rule at src/opts/bitops.isle line 544.
                                                                                        returns.extend(Some(v873));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                if v99.1 == v135.1 {
                                                                    let mut v102 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v99.0, &mut v102);
                                                                    let mut v102 = v102.into_context_iter();
                                                                    while let Some(v103) = v102.next(ctx) {
                                                                        if let &InstructionData::Unary {
                                                                            opcode: ref v106,
                                                                            arg: v107,
                                                                        } = &v103.1 {
                                                                            if let &Opcode::Bnot = v106 {
                                                                                if v107 == v135.0 {
                                                                                    if v2.0 == v103.0 {
                                                                                        let v870 = constructor_bxor(ctx, v2.0, v99.1, v107);
                                                                                        let v871 = constructor_isub(ctx, v2.0, v870, v107);
                                                                                        // Rule at src/opts/bitops.isle line 541.
                                                                                        returns.extend(Some(v871));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    let mut v274 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v135.0, &mut v274);
                                                                    let mut v274 = v274.into_context_iter();
                                                                    while let Some(v275) = v274.next(ctx) {
                                                                        if let &InstructionData::Unary {
                                                                            opcode: ref v630,
                                                                            arg: v631,
                                                                        } = &v275.1 {
                                                                            if let &Opcode::Bnot = v630 {
                                                                                if v99.0 == v631 {
                                                                                    if v2.0 == v275.0 {
                                                                                        let v239 = constructor_bxor(ctx, v2.0, v99.1, v99.0);
                                                                                        let v873 = constructor_isub(ctx, v2.0, v99.0, v239);
                                                                                        // Rule at src/opts/bitops.isle line 545.
                                                                                        returns.extend(Some(v873));
                                                                                        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 v133,
                                                        args: ref v134,
                                                    } = &v11.1 {
                                                        match v133 {
                                                            &Opcode::Band => {
                                                                if v2.0 == v11.0 {
                                                                    let v99 = C::unpack_value_array_2(ctx, v98);
                                                                    let v135 = C::unpack_value_array_2(ctx, v134);
                                                                    if v99.0 == v135.0 {
                                                                        if v99.1 == v135.1 {
                                                                            let v238 = constructor_bxor(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/arithmetic.isle line 300.
                                                                            returns.extend(Some(v238));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            let v239 = constructor_bxor(ctx, v2.0, v99.1, v99.0);
                                                                            // Rule at src/opts/arithmetic.isle line 303.
                                                                            returns.extend(Some(v239));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v99.0 == v135.1 {
                                                                        if v99.1 == v135.0 {
                                                                            let v238 = constructor_bxor(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/arithmetic.isle line 301.
                                                                            returns.extend(Some(v238));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            let v239 = constructor_bxor(ctx, v2.0, v99.1, v99.0);
                                                                            // Rule at src/opts/arithmetic.isle line 302.
                                                                            returns.extend(Some(v239));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Bxor => {
                                                                if v2.0 == v11.0 {
                                                                    let v99 = C::unpack_value_array_2(ctx, v98);
                                                                    let v135 = C::unpack_value_array_2(ctx, v134);
                                                                    if v99.0 == v135.0 {
                                                                        if v99.1 == v135.1 {
                                                                            let v138 = constructor_band(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/arithmetic.isle line 312.
                                                                            returns.extend(Some(v138));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            let v242 = constructor_band(ctx, v2.0, v99.1, v99.0);
                                                                            // Rule at src/opts/arithmetic.isle line 315.
                                                                            returns.extend(Some(v242));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v99.0 == v135.1 {
                                                                        if v99.1 == v135.0 {
                                                                            let v138 = constructor_band(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/arithmetic.isle line 313.
                                                                            returns.extend(Some(v138));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            let v242 = constructor_band(ctx, v2.0, v99.1, v99.0);
                                                                            // Rule at src/opts/arithmetic.isle line 314.
                                                                            returns.extend(Some(v242));
                                                                            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 v133,
                                                        args: ref v134,
                                                    } = &v11.1 {
                                                        if let &Opcode::Ishl = v133 {
                                                            if v2.0 == v11.0 {
                                                                let v99 = C::unpack_value_array_2(ctx, v98);
                                                                let v135 = C::unpack_value_array_2(ctx, v134);
                                                                if v99.1 == v135.1 {
                                                                    let v248 = constructor_isub(ctx, v2.0, v99.0, v135.0);
                                                                    let v1905 = constructor_ishl(ctx, v2.0, v248, v99.1);
                                                                    // Rule at src/opts/shifts.isle line 313.
                                                                    returns.extend(Some(v1905));
                                                                    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 v1849 = C::lane_type(ctx, v2.0);
                                                                let v1997 = constructor_isub(ctx, v1849, v30, v27);
                                                                let v1998 = constructor_splat(ctx, v2.0, v1997);
                                                                // Rule at src/opts/vector.isle line 33.
                                                                returns.extend(Some(v1998));
                                                                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 v924 = constructor_isub(ctx, v2.0, v27, v30);
                                                                // Rule at src/opts/bitops.isle line 648.
                                                                returns.extend(Some(v924));
                                                                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 v1020 = constructor_isub(ctx, v2.0, v7.1, v7.0);
                                            let v1021 = constructor_ineg(ctx, v2.0, v1020);
                                            // Rule at src/opts/cprop.isle line 151.
                                            returns.extend(Some(v1021));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        let v334 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v335) = v334 {
                                            if v19.0 == v335 {
                                                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 v955 = C::imm64_sub(ctx, v335, v23, v15);
                                                                let v956 = constructor_iconst(ctx, v335, v955);
                                                                let v957 = C::subsume(ctx, v956);
                                                                // Rule at src/opts/cprop.isle line 19.
                                                                returns.extend(Some(v957));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        let v1605 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 7.
                                        returns.extend(Some(v1605));
                                        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 v133,
                                    args: ref v134,
                                } => {
                                    if let &Opcode::Iadd = v133 {
                                        if v2.0 == v11.0 {
                                            let v135 = C::unpack_value_array_2(ctx, v134);
                                            if v7.0 == v135.0 {
                                                let v256 = constructor_ineg(ctx, v2.0, v135.1);
                                                // Rule at src/opts/arithmetic.isle line 366.
                                                returns.extend(Some(v256));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            if v7.0 == v135.1 {
                                                let v257 = constructor_ineg(ctx, v2.0, v135.0);
                                                // Rule at src/opts/arithmetic.isle line 367.
                                                returns.extend(Some(v257));
                                                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 v1605 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 9.
                                        returns.extend(Some(v1605));
                                        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 v1082 = C::i64_wrapping_neg(ctx, v59.1);
                                let v1083 = C::i64_cast_unsigned(ctx, v1082);
                                let v1084 = C::i64_cast_unsigned(ctx, v59.1);
                                let v1085 = C::u64_lt(ctx, v1083, v1084);
                                if v1085 == true {
                                    if v2.0 == v59.0 {
                                        let v1086 = C::imm64(ctx, v1084);
                                        let v1087 = C::imm64_neg(ctx, v2.0, v1086);
                                        let v1088 = constructor_iconst(ctx, v2.0, v1087);
                                        let v1089 = constructor_iadd(ctx, v2.0, v7.0, v1088);
                                        // Rule at src/opts/cprop.isle line 268.
                                        returns.extend(Some(v1089));
                                        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 v133,
                                    args: ref v134,
                                } => {
                                    match v133 {
                                        &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 v97,
                                                        args: ref v98,
                                                    } = &v19.1 {
                                                        if let &Opcode::Imul = v97 {
                                                            if v2.0 == v19.0 {
                                                                let v99 = C::unpack_value_array_2(ctx, v98);
                                                                let mut v109 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                                let mut v109 = v109.into_context_iter();
                                                                while let Some(v110) = v109.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v127,
                                                                        imm: v128,
                                                                    } = &v110.1 {
                                                                        if let &Opcode::Iconst = v127 {
                                                                            let v135 = C::unpack_value_array_2(ctx, v134);
                                                                            let mut v258 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v135.1, &mut v258);
                                                                            let mut v258 = v258.into_context_iter();
                                                                            while let Some(v259) = v258.next(ctx) {
                                                                                if let &InstructionData::UnaryImm {
                                                                                    opcode: ref v1124,
                                                                                    imm: v1125,
                                                                                } = &v259.1 {
                                                                                    if let &Opcode::Iconst = v1124 {
                                                                                        let v1128 = constructor_imul(ctx, v2.0, v99.0, v135.0);
                                                                                        let v1129 = constructor_imul(ctx, v2.0, v99.1, v135.1);
                                                                                        let v1130 = constructor_imul(ctx, v2.0, v1128, v1129);
                                                                                        // Rule at src/opts/cprop.isle line 317.
                                                                                        returns.extend(Some(v1130));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Ishl => {
                                            if v2.0 == v11.0 {
                                                let v135 = C::unpack_value_array_2(ctx, v134);
                                                let mut v139 = C::inst_data_value_tupled_etor_returns::default();
                                                C::inst_data_value_tupled_etor(ctx, v135.0, &mut v139);
                                                let mut v139 = v139.into_context_iter();
                                                while let Some(v140) = v139.next(ctx) {
                                                    let v141 = C::iconst_sextend_etor(ctx, v140);
                                                    if let Some(v142) = v141 {
                                                        if v142.1 == 1_i64 {
                                                            if v2.0 == v142.0 {
                                                                let v145 = constructor_ishl(ctx, v2.0, v7.0, v135.1);
                                                                // Rule at src/opts/arithmetic.isle line 235.
                                                                returns.extend(Some(v145));
                                                                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 v1849 = C::lane_type(ctx, v2.0);
                                                                let v1999 = constructor_imul(ctx, v1849, v30, v27);
                                                                let v2000 = constructor_splat(ctx, v2.0, v1999);
                                                                // Rule at src/opts/vector.isle line 36.
                                                                returns.extend(Some(v2000));
                                                                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 v97,
                                                    args: ref v98,
                                                } => {
                                                    if let &Opcode::Imul = v97 {
                                                        if v2.0 == v11.0 {
                                                            if v2.0 == v19.0 {
                                                                let v99 = C::unpack_value_array_2(ctx, v98);
                                                                let mut v109 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                                let mut v109 = v109.into_context_iter();
                                                                while let Some(v110) = v109.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v127,
                                                                        imm: v128,
                                                                    } = &v110.1 {
                                                                        if let &Opcode::Iconst = v127 {
                                                                            if v2.0 == v110.0 {
                                                                                let v1049 = constructor_imul(ctx, v2.0, v99.1, v7.1);
                                                                                let v1050 = constructor_imul(ctx, v2.0, v99.0, v1049);
                                                                                // Rule at src/opts/cprop.isle line 213.
                                                                                returns.extend(Some(v1050));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                &InstructionData::Unary {
                                                    opcode: ref v29,
                                                    arg: v30,
                                                } => {
                                                    if let &Opcode::Ineg = v29 {
                                                        let v334 = C::fits_in_64(ctx, v2.0);
                                                        if let Some(v335) = v334 {
                                                            if v11.0 == v19.0 {
                                                                if v11.0 == v335 {
                                                                    let v336 = C::imm64_neg(ctx, v335, v15);
                                                                    let v337 = constructor_iconst(ctx, v335, v336);
                                                                    let v338 = constructor_imul(ctx, v335, v30, v337);
                                                                    // Rule at src/opts/arithmetic.isle line 569.
                                                                    returns.extend(Some(v338));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                &InstructionData::UnaryImm {
                                                    opcode: ref v22,
                                                    imm: v23,
                                                } => {
                                                    if let &Opcode::Iconst = v22 {
                                                        let v334 = C::fits_in_64(ctx, v2.0);
                                                        if let Some(v335) = v334 {
                                                            if v11.0 == v19.0 {
                                                                if v11.0 == v335 {
                                                                    let v958 = C::imm64_mul(ctx, v335, v23, v15);
                                                                    let v959 = constructor_iconst(ctx, v335, v958);
                                                                    let v960 = C::subsume(ctx, v959);
                                                                    // Rule at src/opts/cprop.isle line 25.
                                                                    returns.extend(Some(v960));
                                                                    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 {
                                    if v2.0 == v19.0 {
                                        let v1022 = constructor_imul(ctx, v2.0, v7.1, v7.0);
                                        // Rule at src/opts/cprop.isle line 154.
                                        returns.extend(Some(v1022));
                                        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 v1849 = C::lane_type(ctx, v2.0);
                                                        let v2003 = constructor_umulhi(ctx, v1849, v30, v27);
                                                        let v2004 = constructor_splat(ctx, v2.0, v2003);
                                                        // Rule at src/opts/vector.isle line 42.
                                                        returns.extend(Some(v2004));
                                                        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 v1849 = C::lane_type(ctx, v2.0);
                                                        let v2001 = constructor_smulhi(ctx, v1849, v30, v27);
                                                        let v2002 = constructor_splat(ctx, v2.0, v2001);
                                                        // Rule at src/opts/vector.isle line 39.
                                                        returns.extend(Some(v2002));
                                                        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 v133,
                                    args: ref v134,
                                } => {
                                    match v133 {
                                        &Opcode::Band => {
                                            if v2.0 == v11.0 {
                                                let v135 = C::unpack_value_array_2(ctx, v134);
                                                if v7.0 == v135.0 {
                                                    let v623 = constructor_band(ctx, v2.0, v7.0, v135.1);
                                                    // Rule at src/opts/bitops.isle line 194.
                                                    returns.extend(Some(v623));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.0 == v135.1 {
                                                    let v624 = constructor_band(ctx, v2.0, v135.0, v7.0);
                                                    // Rule at src/opts/bitops.isle line 195.
                                                    returns.extend(Some(v624));
                                                    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 v97,
                                                        args: ref v98,
                                                    } = &v19.1 {
                                                        if let &Opcode::Band = v97 {
                                                            if v2.0 == v19.0 {
                                                                let v99 = C::unpack_value_array_2(ctx, v98);
                                                                let mut v109 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                                let mut v109 = v109.into_context_iter();
                                                                while let Some(v110) = v109.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v127,
                                                                        imm: v128,
                                                                    } = &v110.1 {
                                                                        if let &Opcode::Iconst = v127 {
                                                                            let mut v258 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v135.1, &mut v258);
                                                                            let mut v258 = v258.into_context_iter();
                                                                            while let Some(v259) = v258.next(ctx) {
                                                                                if let &InstructionData::UnaryImm {
                                                                                    opcode: ref v1124,
                                                                                    imm: v1125,
                                                                                } = &v259.1 {
                                                                                    if let &Opcode::Iconst = v1124 {
                                                                                        let v668 = constructor_band(ctx, v2.0, v99.0, v135.0);
                                                                                        let v1131 = constructor_band(ctx, v2.0, v99.1, v135.1);
                                                                                        let v1132 = constructor_band(ctx, v2.0, v668, v1131);
                                                                                        // Rule at src/opts/cprop.isle line 321.
                                                                                        returns.extend(Some(v1132));
                                                                                        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 v97,
                                                            args: ref v98,
                                                        } => {
                                                            if let &Opcode::Bor = v97 {
                                                                if v2.0 == v19.0 {
                                                                    let v99 = C::unpack_value_array_2(ctx, v98);
                                                                    let v135 = C::unpack_value_array_2(ctx, v134);
                                                                    if v99.0 == v135.0 {
                                                                        let mut v109 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                                        let mut v109 = v109.into_context_iter();
                                                                        while let Some(v110) = v109.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v113,
                                                                                arg: v114,
                                                                            } = &v110.1 {
                                                                                if let &Opcode::Bnot = v113 {
                                                                                    if v2.0 == v110.0 {
                                                                                        if v114 == v135.1 {
                                                                                            // Rule at src/opts/bitops.isle line 475.
                                                                                            returns.extend(Some(v99.0));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let mut v258 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v135.1, &mut v258);
                                                                        let mut v258 = v258.into_context_iter();
                                                                        while let Some(v259) = v258.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v627,
                                                                                arg: v628,
                                                                            } = &v259.1 {
                                                                                if let &Opcode::Bnot = v627 {
                                                                                    if v99.1 == v628 {
                                                                                        if v2.0 == v259.0 {
                                                                                            // Rule at src/opts/bitops.isle line 474.
                                                                                            returns.extend(Some(v99.0));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let v680 = constructor_band(ctx, v2.0, v99.1, v135.1);
                                                                        let v681 = constructor_bor(ctx, v2.0, v680, v99.0);
                                                                        // Rule at src/opts/bitops.isle line 261.
                                                                        returns.extend(Some(v681));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        let v682 = constructor_band(ctx, v2.0, v135.1, v99.1);
                                                                        let v683 = constructor_bor(ctx, v2.0, v682, v99.0);
                                                                        // Rule at src/opts/bitops.isle line 262.
                                                                        returns.extend(Some(v683));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v99.0 == v135.1 {
                                                                        let mut v109 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                                        let mut v109 = v109.into_context_iter();
                                                                        while let Some(v110) = v109.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v113,
                                                                                arg: v114,
                                                                            } = &v110.1 {
                                                                                if let &Opcode::Bnot = v113 {
                                                                                    if v114 == v135.0 {
                                                                                        if v2.0 == v110.0 {
                                                                                            // Rule at src/opts/bitops.isle line 479.
                                                                                            returns.extend(Some(v99.0));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let mut v274 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v135.0, &mut v274);
                                                                        let mut v274 = v274.into_context_iter();
                                                                        while let Some(v275) = v274.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v630,
                                                                                arg: v631,
                                                                            } = &v275.1 {
                                                                                if let &Opcode::Bnot = v630 {
                                                                                    if v99.1 == v631 {
                                                                                        if v2.0 == v275.0 {
                                                                                            // Rule at src/opts/bitops.isle line 476.
                                                                                            returns.extend(Some(v99.0));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let v674 = constructor_band(ctx, v2.0, v135.0, v99.1);
                                                                        let v675 = constructor_bor(ctx, v2.0, v674, v99.0);
                                                                        // Rule at src/opts/bitops.isle line 258.
                                                                        returns.extend(Some(v675));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        let v676 = constructor_band(ctx, v2.0, v99.1, v135.0);
                                                                        let v677 = constructor_bor(ctx, v2.0, v676, v99.0);
                                                                        // Rule at src/opts/bitops.isle line 259.
                                                                        returns.extend(Some(v677));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v99.1 == v135.0 {
                                                                        let mut v102 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v99.0, &mut v102);
                                                                        let mut v102 = v102.into_context_iter();
                                                                        while let Some(v103) = v102.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v106,
                                                                                arg: v107,
                                                                            } = &v103.1 {
                                                                                if let &Opcode::Bnot = v106 {
                                                                                    if v107 == v135.1 {
                                                                                        if v2.0 == v103.0 {
                                                                                            // Rule at src/opts/bitops.isle line 477.
                                                                                            returns.extend(Some(v99.1));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let mut v258 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v135.1, &mut v258);
                                                                        let mut v258 = v258.into_context_iter();
                                                                        while let Some(v259) = v258.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v627,
                                                                                arg: v628,
                                                                            } = &v259.1 {
                                                                                if let &Opcode::Bnot = v627 {
                                                                                    if v99.0 == v628 {
                                                                                        if v2.0 == v259.0 {
                                                                                            // Rule at src/opts/bitops.isle line 478.
                                                                                            returns.extend(Some(v99.1));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let v672 = constructor_band(ctx, v2.0, v99.0, v135.1);
                                                                        let v673 = constructor_bor(ctx, v2.0, v672, v99.1);
                                                                        // Rule at src/opts/bitops.isle line 257.
                                                                        returns.extend(Some(v673));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        let v678 = constructor_band(ctx, v2.0, v135.1, v99.0);
                                                                        let v679 = constructor_bor(ctx, v2.0, v678, v99.1);
                                                                        // Rule at src/opts/bitops.isle line 260.
                                                                        returns.extend(Some(v679));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v99.1 == v135.1 {
                                                                        let mut v102 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v99.0, &mut v102);
                                                                        let mut v102 = v102.into_context_iter();
                                                                        while let Some(v103) = v102.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v106,
                                                                                arg: v107,
                                                                            } = &v103.1 {
                                                                                if let &Opcode::Bnot = v106 {
                                                                                    if v107 == v135.0 {
                                                                                        if v2.0 == v103.0 {
                                                                                            // Rule at src/opts/bitops.isle line 481.
                                                                                            returns.extend(Some(v99.1));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let mut v274 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v135.0, &mut v274);
                                                                        let mut v274 = v274.into_context_iter();
                                                                        while let Some(v275) = v274.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v630,
                                                                                arg: v631,
                                                                            } = &v275.1 {
                                                                                if let &Opcode::Bnot = v630 {
                                                                                    if v99.0 == v631 {
                                                                                        if v2.0 == v275.0 {
                                                                                            // Rule at src/opts/bitops.isle line 480.
                                                                                            returns.extend(Some(v99.1));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let v668 = constructor_band(ctx, v2.0, v99.0, v135.0);
                                                                        let v669 = constructor_bor(ctx, v2.0, v668, v99.1);
                                                                        // Rule at src/opts/bitops.isle line 255.
                                                                        returns.extend(Some(v669));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        let v670 = constructor_band(ctx, v2.0, v135.0, v99.0);
                                                                        let v671 = constructor_bor(ctx, v2.0, v670, v99.1);
                                                                        // Rule at src/opts/bitops.isle line 256.
                                                                        returns.extend(Some(v671));
                                                                        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 v649 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v30, &mut v649);
                                                                    let mut v649 = v649.into_context_iter();
                                                                    while let Some(v650) = v649.next(ctx) {
                                                                        if let &InstructionData::Binary {
                                                                            opcode: ref v653,
                                                                            args: ref v654,
                                                                        } = &v650.1 {
                                                                            match v653 {
                                                                                &Opcode::Band => {
                                                                                    if v2.0 == v650.0 {
                                                                                        let v135 = C::unpack_value_array_2(ctx, v134);
                                                                                        let mut v258 = C::inst_data_value_etor_returns::default();
                                                                                        C::inst_data_value_etor(ctx, v135.1, &mut v258);
                                                                                        let mut v258 = v258.into_context_iter();
                                                                                        while let Some(v259) = v258.next(ctx) {
                                                                                            if let &InstructionData::Unary {
                                                                                                opcode: ref v627,
                                                                                                arg: v628,
                                                                                            } = &v259.1 {
                                                                                                if let &Opcode::Bnot = v627 {
                                                                                                    if v2.0 == v259.0 {
                                                                                                        let v655 = C::unpack_value_array_2(ctx, v654);
                                                                                                        if v135.0 == v655.0 {
                                                                                                            if v628 == v655.1 {
                                                                                                                let v738 = constructor_bnot(ctx, v2.0, v655.1);
                                                                                                                // Rule at src/opts/bitops.isle line 668.
                                                                                                                returns.extend(Some(v738));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                        if v628 == v655.0 {
                                                                                                            if v135.0 == v655.1 {
                                                                                                                let v734 = constructor_bnot(ctx, v2.0, v655.0);
                                                                                                                // Rule at src/opts/bitops.isle line 666.
                                                                                                                returns.extend(Some(v734));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                        let mut v274 = C::inst_data_value_etor_returns::default();
                                                                                        C::inst_data_value_etor(ctx, v135.0, &mut v274);
                                                                                        let mut v274 = v274.into_context_iter();
                                                                                        while let Some(v275) = v274.next(ctx) {
                                                                                            if let &InstructionData::Unary {
                                                                                                opcode: ref v630,
                                                                                                arg: v631,
                                                                                            } = &v275.1 {
                                                                                                if let &Opcode::Bnot = v630 {
                                                                                                    if v2.0 == v275.0 {
                                                                                                        let v655 = C::unpack_value_array_2(ctx, v654);
                                                                                                        if v135.1 == v655.0 {
                                                                                                            if v631 == v655.1 {
                                                                                                                let v738 = constructor_bnot(ctx, v2.0, v655.1);
                                                                                                                // Rule at src/opts/bitops.isle line 664.
                                                                                                                returns.extend(Some(v738));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                        if v631 == v655.0 {
                                                                                                            if v135.1 == v655.1 {
                                                                                                                let v734 = constructor_bnot(ctx, v2.0, v655.0);
                                                                                                                // Rule at src/opts/bitops.isle line 662.
                                                                                                                returns.extend(Some(v734));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                                &Opcode::Bxor => {
                                                                                    if v2.0 == v650.0 {
                                                                                        let v135 = C::unpack_value_array_2(ctx, v134);
                                                                                        let v655 = C::unpack_value_array_2(ctx, v654);
                                                                                        if v135.0 == v655.0 {
                                                                                            if v135.1 == v655.1 {
                                                                                                let v882 = constructor_band(ctx, v2.0, v655.0, v655.1);
                                                                                                // Rule at src/opts/bitops.isle line 581.
                                                                                                returns.extend(Some(v882));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v883 = constructor_band(ctx, v2.0, v655.1, v655.0);
                                                                                                // Rule at src/opts/bitops.isle line 587.
                                                                                                returns.extend(Some(v883));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                        if v135.0 == v655.1 {
                                                                                            if v135.1 == v655.0 {
                                                                                                let v883 = constructor_band(ctx, v2.0, v655.1, v655.0);
                                                                                                // Rule at src/opts/bitops.isle line 583.
                                                                                                returns.extend(Some(v883));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v882 = constructor_band(ctx, v2.0, v655.0, v655.1);
                                                                                                // Rule at src/opts/bitops.isle line 585.
                                                                                                returns.extend(Some(v882));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                                _ => {}
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let v135 = C::unpack_value_array_2(ctx, v134);
                                                let mut v258 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v135.1, &mut v258);
                                                let mut v258 = v258.into_context_iter();
                                                while let Some(v259) = v258.next(ctx) {
                                                    match &v259.1 {
                                                        &InstructionData::Binary {
                                                            opcode: ref v262,
                                                            args: ref v263,
                                                        } => {
                                                            if let &Opcode::Band = v262 {
                                                                if v2.0 == v259.0 {
                                                                    let v264 = C::unpack_value_array_2(ctx, v263);
                                                                    if v7.0 == v264.0 {
                                                                        let v848 = constructor_bor(ctx, v2.0, v135.0, v264.1);
                                                                        let v849 = constructor_band(ctx, v2.0, v848, v7.0);
                                                                        // Rule at src/opts/bitops.isle line 507.
                                                                        returns.extend(Some(v849));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v7.0 == v264.1 {
                                                                        let v856 = constructor_bor(ctx, v2.0, v135.0, v264.0);
                                                                        let v857 = constructor_band(ctx, v2.0, v856, v7.0);
                                                                        // Rule at src/opts/bitops.isle line 511.
                                                                        returns.extend(Some(v857));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v627,
                                                            arg: v628,
                                                        } => {
                                                            if let &Opcode::Bnot = v627 {
                                                                if v7.0 == v628 {
                                                                    if v2.0 == v259.0 {
                                                                        let v864 = constructor_band(ctx, v2.0, v7.0, v135.0);
                                                                        // Rule at src/opts/bitops.isle line 528.
                                                                        returns.extend(Some(v864));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let mut v274 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v135.0, &mut v274);
                                                let mut v274 = v274.into_context_iter();
                                                while let Some(v275) = v274.next(ctx) {
                                                    match &v275.1 {
                                                        &InstructionData::Binary {
                                                            opcode: ref v278,
                                                            args: ref v279,
                                                        } => {
                                                            if let &Opcode::Band = v278 {
                                                                if v2.0 == v275.0 {
                                                                    let v280 = C::unpack_value_array_2(ctx, v279);
                                                                    if v7.0 == v280.0 {
                                                                        let v852 = constructor_bor(ctx, v2.0, v135.1, v280.1);
                                                                        let v853 = constructor_band(ctx, v2.0, v852, v7.0);
                                                                        // Rule at src/opts/bitops.isle line 509.
                                                                        returns.extend(Some(v853));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v7.0 == v280.1 {
                                                                        let v860 = constructor_bor(ctx, v2.0, v135.1, v280.0);
                                                                        let v861 = constructor_band(ctx, v2.0, v860, v7.0);
                                                                        // Rule at src/opts/bitops.isle line 513.
                                                                        returns.extend(Some(v861));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v630,
                                                            arg: v631,
                                                        } => {
                                                            if let &Opcode::Bnot = v630 {
                                                                if v7.0 == v631 {
                                                                    if v2.0 == v275.0 {
                                                                        let v623 = constructor_band(ctx, v2.0, v7.0, v135.1);
                                                                        // Rule at src/opts/bitops.isle line 526.
                                                                        returns.extend(Some(v623));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                if v7.0 == v135.0 {
                                                    // Rule at src/opts/bitops.isle line 250.
                                                    returns.extend(Some(v7.0));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.0 == v135.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 v97,
                                                        args: ref v98,
                                                    } = &v19.1 {
                                                        if let &Opcode::Bxor = v97 {
                                                            if v2.0 == v19.0 {
                                                                let v99 = C::unpack_value_array_2(ctx, v98);
                                                                let v135 = C::unpack_value_array_2(ctx, v134);
                                                                if v99.0 == v135.0 {
                                                                    let mut v109 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                                    let mut v109 = v109.into_context_iter();
                                                                    while let Some(v110) = v109.next(ctx) {
                                                                        if let &InstructionData::Binary {
                                                                            opcode: ref v268,
                                                                            args: ref v269,
                                                                        } = &v110.1 {
                                                                            if let &Opcode::Bxor = v268 {
                                                                                if v2.0 == v110.0 {
                                                                                    let v270 = C::unpack_value_array_2(ctx, v269);
                                                                                    if v135.1 == v270.0 {
                                                                                        let v897 = constructor_bxor(ctx, v2.0, v99.0, v270.0);
                                                                                        let v898 = constructor_bnot(ctx, v2.0, v270.1);
                                                                                        let v899 = constructor_band(ctx, v2.0, v897, v898);
                                                                                        // Rule at src/opts/bitops.isle line 627.
                                                                                        returns.extend(Some(v899));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v135.1 == v270.1 {
                                                                                        let v907 = constructor_bxor(ctx, v2.0, v99.0, v270.1);
                                                                                        let v908 = constructor_bnot(ctx, v2.0, v270.0);
                                                                                        let v909 = constructor_band(ctx, v2.0, v907, v908);
                                                                                        // Rule at src/opts/bitops.isle line 631.
                                                                                        returns.extend(Some(v909));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    let mut v258 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v135.1, &mut v258);
                                                                    let mut v258 = v258.into_context_iter();
                                                                    while let Some(v259) = v258.next(ctx) {
                                                                        if let &InstructionData::Binary {
                                                                            opcode: ref v262,
                                                                            args: ref v263,
                                                                        } = &v259.1 {
                                                                            if let &Opcode::Bxor = v262 {
                                                                                if v2.0 == v259.0 {
                                                                                    let v264 = C::unpack_value_array_2(ctx, v263);
                                                                                    if v99.1 == v264.0 {
                                                                                        let v238 = constructor_bxor(ctx, v2.0, v99.0, v99.1);
                                                                                        let v895 = constructor_bnot(ctx, v2.0, v264.1);
                                                                                        let v896 = constructor_band(ctx, v2.0, v238, v895);
                                                                                        // Rule at src/opts/bitops.isle line 626.
                                                                                        returns.extend(Some(v896));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v99.1 == v264.1 {
                                                                                        let v238 = constructor_bxor(ctx, v2.0, v99.0, v99.1);
                                                                                        let v905 = constructor_bnot(ctx, v2.0, v264.0);
                                                                                        let v906 = constructor_band(ctx, v2.0, v238, v905);
                                                                                        // Rule at src/opts/bitops.isle line 630.
                                                                                        returns.extend(Some(v906));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                if v99.0 == v135.1 {
                                                                    let mut v109 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                                    let mut v109 = v109.into_context_iter();
                                                                    while let Some(v110) = v109.next(ctx) {
                                                                        if let &InstructionData::Binary {
                                                                            opcode: ref v268,
                                                                            args: ref v269,
                                                                        } = &v110.1 {
                                                                            if let &Opcode::Bxor = v268 {
                                                                                if v2.0 == v110.0 {
                                                                                    let v270 = C::unpack_value_array_2(ctx, v269);
                                                                                    if v135.0 == v270.0 {
                                                                                        let v897 = constructor_bxor(ctx, v2.0, v99.0, v270.0);
                                                                                        let v898 = constructor_bnot(ctx, v2.0, v270.1);
                                                                                        let v899 = constructor_band(ctx, v2.0, v897, v898);
                                                                                        // Rule at src/opts/bitops.isle line 635.
                                                                                        returns.extend(Some(v899));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v135.0 == v270.1 {
                                                                                        let v907 = constructor_bxor(ctx, v2.0, v99.0, v270.1);
                                                                                        let v908 = constructor_bnot(ctx, v2.0, v270.0);
                                                                                        let v909 = constructor_band(ctx, v2.0, v907, v908);
                                                                                        // Rule at src/opts/bitops.isle line 639.
                                                                                        returns.extend(Some(v909));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    let mut v274 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v135.0, &mut v274);
                                                                    let mut v274 = v274.into_context_iter();
                                                                    while let Some(v275) = v274.next(ctx) {
                                                                        if let &InstructionData::Binary {
                                                                            opcode: ref v278,
                                                                            args: ref v279,
                                                                        } = &v275.1 {
                                                                            if let &Opcode::Bxor = v278 {
                                                                                if v2.0 == v275.0 {
                                                                                    let v280 = C::unpack_value_array_2(ctx, v279);
                                                                                    if v99.1 == v280.0 {
                                                                                        let v238 = constructor_bxor(ctx, v2.0, v99.0, v99.1);
                                                                                        let v890 = constructor_bnot(ctx, v2.0, v280.1);
                                                                                        let v891 = constructor_band(ctx, v2.0, v238, v890);
                                                                                        // Rule at src/opts/bitops.isle line 624.
                                                                                        returns.extend(Some(v891));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v99.1 == v280.1 {
                                                                                        let v238 = constructor_bxor(ctx, v2.0, v99.0, v99.1);
                                                                                        let v900 = constructor_bnot(ctx, v2.0, v280.0);
                                                                                        let v901 = constructor_band(ctx, v2.0, v238, v900);
                                                                                        // Rule at src/opts/bitops.isle line 628.
                                                                                        returns.extend(Some(v901));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                if v99.1 == v135.0 {
                                                                    let mut v102 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v99.0, &mut v102);
                                                                    let mut v102 = v102.into_context_iter();
                                                                    while let Some(v103) = v102.next(ctx) {
                                                                        if let &InstructionData::Binary {
                                                                            opcode: ref v284,
                                                                            args: ref v285,
                                                                        } = &v103.1 {
                                                                            if let &Opcode::Bxor = v284 {
                                                                                if v2.0 == v103.0 {
                                                                                    let v286 = C::unpack_value_array_2(ctx, v285);
                                                                                    if v135.1 == v286.0 {
                                                                                        let v892 = constructor_bxor(ctx, v2.0, v99.1, v286.0);
                                                                                        let v893 = constructor_bnot(ctx, v2.0, v286.1);
                                                                                        let v894 = constructor_band(ctx, v2.0, v892, v893);
                                                                                        // Rule at src/opts/bitops.isle line 625.
                                                                                        returns.extend(Some(v894));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v135.1 == v286.1 {
                                                                                        let v902 = constructor_bxor(ctx, v2.0, v99.1, v286.1);
                                                                                        let v903 = constructor_bnot(ctx, v2.0, v286.0);
                                                                                        let v904 = constructor_band(ctx, v2.0, v902, v903);
                                                                                        // Rule at src/opts/bitops.isle line 629.
                                                                                        returns.extend(Some(v904));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    let mut v258 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v135.1, &mut v258);
                                                                    let mut v258 = v258.into_context_iter();
                                                                    while let Some(v259) = v258.next(ctx) {
                                                                        if let &InstructionData::Binary {
                                                                            opcode: ref v262,
                                                                            args: ref v263,
                                                                        } = &v259.1 {
                                                                            if let &Opcode::Bxor = v262 {
                                                                                if v2.0 == v259.0 {
                                                                                    let v264 = C::unpack_value_array_2(ctx, v263);
                                                                                    if v99.0 == v264.0 {
                                                                                        let v239 = constructor_bxor(ctx, v2.0, v99.1, v99.0);
                                                                                        let v895 = constructor_bnot(ctx, v2.0, v264.1);
                                                                                        let v911 = constructor_band(ctx, v2.0, v239, v895);
                                                                                        // Rule at src/opts/bitops.isle line 634.
                                                                                        returns.extend(Some(v911));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v99.0 == v264.1 {
                                                                                        let v239 = constructor_bxor(ctx, v2.0, v99.1, v99.0);
                                                                                        let v905 = constructor_bnot(ctx, v2.0, v264.0);
                                                                                        let v913 = constructor_band(ctx, v2.0, v239, v905);
                                                                                        // Rule at src/opts/bitops.isle line 638.
                                                                                        returns.extend(Some(v913));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                if v99.1 == v135.1 {
                                                                    let mut v102 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v99.0, &mut v102);
                                                                    let mut v102 = v102.into_context_iter();
                                                                    while let Some(v103) = v102.next(ctx) {
                                                                        if let &InstructionData::Binary {
                                                                            opcode: ref v284,
                                                                            args: ref v285,
                                                                        } = &v103.1 {
                                                                            if let &Opcode::Bxor = v284 {
                                                                                if v2.0 == v103.0 {
                                                                                    let v286 = C::unpack_value_array_2(ctx, v285);
                                                                                    if v135.0 == v286.0 {
                                                                                        let v892 = constructor_bxor(ctx, v2.0, v99.1, v286.0);
                                                                                        let v893 = constructor_bnot(ctx, v2.0, v286.1);
                                                                                        let v894 = constructor_band(ctx, v2.0, v892, v893);
                                                                                        // Rule at src/opts/bitops.isle line 633.
                                                                                        returns.extend(Some(v894));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v135.0 == v286.1 {
                                                                                        let v902 = constructor_bxor(ctx, v2.0, v99.1, v286.1);
                                                                                        let v903 = constructor_bnot(ctx, v2.0, v286.0);
                                                                                        let v904 = constructor_band(ctx, v2.0, v902, v903);
                                                                                        // Rule at src/opts/bitops.isle line 637.
                                                                                        returns.extend(Some(v904));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    let mut v274 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v135.0, &mut v274);
                                                                    let mut v274 = v274.into_context_iter();
                                                                    while let Some(v275) = v274.next(ctx) {
                                                                        if let &InstructionData::Binary {
                                                                            opcode: ref v278,
                                                                            args: ref v279,
                                                                        } = &v275.1 {
                                                                            if let &Opcode::Bxor = v278 {
                                                                                if v2.0 == v275.0 {
                                                                                    let v280 = C::unpack_value_array_2(ctx, v279);
                                                                                    if v99.0 == v280.0 {
                                                                                        let v239 = constructor_bxor(ctx, v2.0, v99.1, v99.0);
                                                                                        let v890 = constructor_bnot(ctx, v2.0, v280.1);
                                                                                        let v910 = constructor_band(ctx, v2.0, v239, v890);
                                                                                        // Rule at src/opts/bitops.isle line 632.
                                                                                        returns.extend(Some(v910));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v99.0 == v280.1 {
                                                                                        let v239 = constructor_bxor(ctx, v2.0, v99.1, v99.0);
                                                                                        let v900 = constructor_bnot(ctx, v2.0, v280.0);
                                                                                        let v912 = constructor_band(ctx, v2.0, v239, v900);
                                                                                        // Rule at src/opts/bitops.isle line 636.
                                                                                        returns.extend(Some(v912));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                let v135 = C::unpack_value_array_2(ctx, v134);
                                                let mut v258 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v135.1, &mut v258);
                                                let mut v258 = v258.into_context_iter();
                                                while let Some(v259) = v258.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v627,
                                                        arg: v628,
                                                    } = &v259.1 {
                                                        if let &Opcode::Bnot = v627 {
                                                            if v2.0 == v259.0 {
                                                                if v7.0 == v628 {
                                                                    let v864 = constructor_band(ctx, v2.0, v7.0, v135.0);
                                                                    // Rule at src/opts/bitops.isle line 610.
                                                                    returns.extend(Some(v864));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v7.0 == v135.0 {
                                                                    let v629 = constructor_band(ctx, v2.0, v7.0, v628);
                                                                    // Rule at src/opts/bitops.isle line 200.
                                                                    returns.extend(Some(v629));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                let mut v274 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v135.0, &mut v274);
                                                let mut v274 = v274.into_context_iter();
                                                while let Some(v275) = v274.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v630,
                                                        arg: v631,
                                                    } = &v275.1 {
                                                        if let &Opcode::Bnot = v630 {
                                                            if v2.0 == v275.0 {
                                                                if v7.0 == v135.1 {
                                                                    let v632 = constructor_band(ctx, v2.0, v7.0, v631);
                                                                    // Rule at src/opts/bitops.isle line 201.
                                                                    returns.extend(Some(v632));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v7.0 == v631 {
                                                                    let v623 = constructor_band(ctx, v2.0, v7.0, v135.1);
                                                                    // Rule at src/opts/bitops.isle line 608.
                                                                    returns.extend(Some(v623));
                                                                    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 v97,
                                                        args: ref v98,
                                                    } = &v19.1 {
                                                        if let &Opcode::Ishl = v97 {
                                                            if v2.0 == v19.0 {
                                                                let v99 = C::unpack_value_array_2(ctx, v98);
                                                                let v135 = C::unpack_value_array_2(ctx, v134);
                                                                if v99.1 == v135.1 {
                                                                    let v668 = constructor_band(ctx, v2.0, v99.0, v135.0);
                                                                    let v1904 = constructor_ishl(ctx, v2.0, v668, v99.1);
                                                                    // Rule at src/opts/shifts.isle line 312.
                                                                    returns.extend(Some(v1904));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::IntCompare {
                                    opcode: ref v755,
                                    args: ref v756,
                                    cond: ref v757,
                                } => {
                                    if let &Opcode::Icmp = v755 {
                                        let mut v18 = C::inst_data_value_etor_returns::default();
                                        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 v749,
                                                args: ref v750,
                                                cond: ref v751,
                                            } = &v19.1 {
                                                if let &Opcode::Icmp = v749 {
                                                    if v11.0 == v19.0 {
                                                        match v751 {
                                                            &IntCC::NotEqual => {
                                                                match v757 {
                                                                    &IntCC::UnsignedGreaterThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v752 = C::unpack_value_array_2(ctx, v750);
                                                                            let v758 = C::unpack_value_array_2(ctx, v756);
                                                                            if v752.0 == v758.1 {
                                                                                let mut v1545 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v752.1, &mut v1545);
                                                                                let mut v1545 = v1545.into_context_iter();
                                                                                while let Some(v1546) = v1545.next(ctx) {
                                                                                    let v1547 = C::iconst_sextend_etor(ctx, v1546);
                                                                                    if let Some(v1548) = v1547 {
                                                                                        if v1548.1 == -1_i64 {
                                                                                            let v1573 = constructor_ult(ctx, v2.0, v752.0, v758.0);
                                                                                            // Rule at src/opts/icmp.isle line 358.
                                                                                            returns.extend(Some(v1573));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            if v752.1 == v758.1 {
                                                                                let mut v1558 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v752.0, &mut v1558);
                                                                                let mut v1558 = v1558.into_context_iter();
                                                                                while let Some(v1559) = v1558.next(ctx) {
                                                                                    let v1560 = C::iconst_sextend_etor(ctx, v1559);
                                                                                    if let Some(v1561) = v1560 {
                                                                                        if v1561.1 == -1_i64 {
                                                                                            let v1575 = constructor_ult(ctx, v2.0, v752.1, v758.0);
                                                                                            // Rule at src/opts/icmp.isle line 364.
                                                                                            returns.extend(Some(v1575));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v752 = C::unpack_value_array_2(ctx, v750);
                                                                            let v758 = C::unpack_value_array_2(ctx, v756);
                                                                            if v752.0 == v758.0 {
                                                                                let mut v1545 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v752.1, &mut v1545);
                                                                                let mut v1545 = v1545.into_context_iter();
                                                                                while let Some(v1546) = v1545.next(ctx) {
                                                                                    let v1547 = C::iconst_sextend_etor(ctx, v1546);
                                                                                    if let Some(v1548) = v1547 {
                                                                                        if v1548.1 == -1_i64 {
                                                                                            let v1574 = constructor_ult(ctx, v2.0, v752.0, v758.1);
                                                                                            // Rule at src/opts/icmp.isle line 361.
                                                                                            returns.extend(Some(v1574));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            if v752.1 == v758.0 {
                                                                                let mut v1558 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v752.0, &mut v1558);
                                                                                let mut v1558 = v1558.into_context_iter();
                                                                                while let Some(v1559) = v1558.next(ctx) {
                                                                                    let v1560 = C::iconst_sextend_etor(ctx, v1559);
                                                                                    if let Some(v1561) = v1560 {
                                                                                        if v1561.1 == -1_i64 {
                                                                                            let v1576 = constructor_ult(ctx, v2.0, v752.1, v758.1);
                                                                                            // Rule at src/opts/icmp.isle line 367.
                                                                                            returns.extend(Some(v1576));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                            &IntCC::SignedGreaterThan => {
                                                                match v757 {
                                                                    &IntCC::SignedLessThan => {
                                                                        let v343 = C::ty_int_vec128(ctx, v2.0);
                                                                        if let Some(v344) = v343 {
                                                                            if v11.0 == v344 {
                                                                                let v752 = C::unpack_value_array_2(ctx, v750);
                                                                                let v758 = C::unpack_value_array_2(ctx, v756);
                                                                                if v752.0 == v758.0 {
                                                                                    if v752.1 == v758.1 {
                                                                                        let v347 = constructor_iconst_u(ctx, v344, 0x0_u64);
                                                                                        // Rule at src/opts/icmp.isle line 319.
                                                                                        returns.extend(Some(v347));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v752 = C::unpack_value_array_2(ctx, v750);
                                                                            let v758 = C::unpack_value_array_2(ctx, v756);
                                                                            if v752.0 == v758.0 {
                                                                                let mut v1545 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v752.1, &mut v1545);
                                                                                let mut v1545 = v1545.into_context_iter();
                                                                                while let Some(v1546) = v1545.next(ctx) {
                                                                                    let v1547 = C::iconst_sextend_etor(ctx, v1546);
                                                                                    if let Some(v1548) = v1547 {
                                                                                        let v1557 = C::i64_gt_eq(ctx, v1548.1, 0_i64);
                                                                                        if v1557 == true {
                                                                                            let mut v1551 = C::inst_data_value_tupled_etor_returns::default();
                                                                                            C::inst_data_value_tupled_etor(ctx, v758.1, &mut v1551);
                                                                                            let mut v1551 = v1551.into_context_iter();
                                                                                            while let Some(v1552) = v1551.next(ctx) {
                                                                                                let v1553 = C::iconst_sextend_etor(ctx, v1552);
                                                                                                if let Some(v1554) = v1553 {
                                                                                                    if v1548.1 == v1554.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 v752.1 == v758.1 {
                                                                                let mut v1558 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v752.0, &mut v1558);
                                                                                let mut v1558 = v1558.into_context_iter();
                                                                                while let Some(v1559) = v1558.next(ctx) {
                                                                                    let v1560 = C::iconst_sextend_etor(ctx, v1559);
                                                                                    if let Some(v1561) = v1560 {
                                                                                        let v1570 = C::i64_lt(ctx, v1561.1, 0_i64);
                                                                                        if v1570 == true {
                                                                                            let mut v1564 = C::inst_data_value_tupled_etor_returns::default();
                                                                                            C::inst_data_value_tupled_etor(ctx, v758.0, &mut v1564);
                                                                                            let mut v1564 = v1564.into_context_iter();
                                                                                            while let Some(v1565) = v1564.next(ctx) {
                                                                                                let v1566 = C::iconst_sextend_etor(ctx, v1565);
                                                                                                if let Some(v1567) = v1566 {
                                                                                                    if v1561.1 == v1567.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 v757 {
                                                                    &IntCC::SignedGreaterThan => {
                                                                        let v343 = C::ty_int_vec128(ctx, v2.0);
                                                                        if let Some(v344) = v343 {
                                                                            if v11.0 == v344 {
                                                                                let v752 = C::unpack_value_array_2(ctx, v750);
                                                                                let v758 = C::unpack_value_array_2(ctx, v756);
                                                                                if v752.0 == v758.0 {
                                                                                    if v752.1 == v758.1 {
                                                                                        let v347 = constructor_iconst_u(ctx, v344, 0x0_u64);
                                                                                        // Rule at src/opts/icmp.isle line 320.
                                                                                        returns.extend(Some(v347));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedGreaterThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v752 = C::unpack_value_array_2(ctx, v750);
                                                                            let v758 = C::unpack_value_array_2(ctx, v756);
                                                                            if v752.0 == v758.0 {
                                                                                let mut v1545 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v752.1, &mut v1545);
                                                                                let mut v1545 = v1545.into_context_iter();
                                                                                while let Some(v1546) = v1545.next(ctx) {
                                                                                    let v1547 = C::iconst_sextend_etor(ctx, v1546);
                                                                                    if let Some(v1548) = v1547 {
                                                                                        let v1571 = C::i64_lt(ctx, v1548.1, 0_i64);
                                                                                        if v1571 == true {
                                                                                            let mut v1551 = C::inst_data_value_tupled_etor_returns::default();
                                                                                            C::inst_data_value_tupled_etor(ctx, v758.1, &mut v1551);
                                                                                            let mut v1551 = v1551.into_context_iter();
                                                                                            while let Some(v1552) = v1551.next(ctx) {
                                                                                                let v1553 = C::iconst_sextend_etor(ctx, v1552);
                                                                                                if let Some(v1554) = v1553 {
                                                                                                    if v1548.1 == v1554.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 v752.1 == v758.1 {
                                                                                let mut v1558 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v752.0, &mut v1558);
                                                                                let mut v1558 = v1558.into_context_iter();
                                                                                while let Some(v1559) = v1558.next(ctx) {
                                                                                    let v1560 = C::iconst_sextend_etor(ctx, v1559);
                                                                                    if let Some(v1561) = v1560 {
                                                                                        let v1572 = C::i64_gt_eq(ctx, v1561.1, 0_i64);
                                                                                        if v1572 == true {
                                                                                            let mut v1564 = C::inst_data_value_tupled_etor_returns::default();
                                                                                            C::inst_data_value_tupled_etor(ctx, v758.0, &mut v1564);
                                                                                            let mut v1564 = v1564.into_context_iter();
                                                                                            while let Some(v1565) = v1564.next(ctx) {
                                                                                                let v1566 = C::iconst_sextend_etor(ctx, v1565);
                                                                                                if let Some(v1567) = v1566 {
                                                                                                    if v1561.1 == v1567.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 v757 {
                                                                    &IntCC::NotEqual => {
                                                                        if v2.0 == v11.0 {
                                                                            let v752 = C::unpack_value_array_2(ctx, v750);
                                                                            let v758 = C::unpack_value_array_2(ctx, v756);
                                                                            if v752.1 == v758.0 {
                                                                                let mut v1551 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v758.1, &mut v1551);
                                                                                let mut v1551 = v1551.into_context_iter();
                                                                                while let Some(v1552) = v1551.next(ctx) {
                                                                                    let v1553 = C::iconst_sextend_etor(ctx, v1552);
                                                                                    if let Some(v1554) = v1553 {
                                                                                        if v1554.1 == -1_i64 {
                                                                                            let v1577 = constructor_ult(ctx, v2.0, v752.1, v752.0);
                                                                                            // Rule at src/opts/icmp.isle line 370.
                                                                                            returns.extend(Some(v1577));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            if v752.1 == v758.1 {
                                                                                let mut v1564 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v758.0, &mut v1564);
                                                                                let mut v1564 = v1564.into_context_iter();
                                                                                while let Some(v1565) = v1564.next(ctx) {
                                                                                    let v1566 = C::iconst_sextend_etor(ctx, v1565);
                                                                                    if let Some(v1567) = v1566 {
                                                                                        if v1567.1 == -1_i64 {
                                                                                            let v1577 = constructor_ult(ctx, v2.0, v752.1, v752.0);
                                                                                            // Rule at src/opts/icmp.isle line 373.
                                                                                            returns.extend(Some(v1577));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedLessThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v752 = C::unpack_value_array_2(ctx, v750);
                                                                            let v758 = C::unpack_value_array_2(ctx, v756);
                                                                            if v752.0 == v758.0 {
                                                                                let mut v1545 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v752.1, &mut v1545);
                                                                                let mut v1545 = v1545.into_context_iter();
                                                                                while let Some(v1546) = v1545.next(ctx) {
                                                                                    let v1547 = C::iconst_sextend_etor(ctx, v1546);
                                                                                    if let Some(v1548) = v1547 {
                                                                                        let v1571 = C::i64_lt(ctx, v1548.1, 0_i64);
                                                                                        if v1571 == true {
                                                                                            let mut v1551 = C::inst_data_value_tupled_etor_returns::default();
                                                                                            C::inst_data_value_tupled_etor(ctx, v758.1, &mut v1551);
                                                                                            let mut v1551 = v1551.into_context_iter();
                                                                                            while let Some(v1552) = v1551.next(ctx) {
                                                                                                let v1553 = C::iconst_sextend_etor(ctx, v1552);
                                                                                                if let Some(v1554) = v1553 {
                                                                                                    if v1548.1 == v1554.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 v752.1 == v758.1 {
                                                                                let mut v1558 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v752.0, &mut v1558);
                                                                                let mut v1558 = v1558.into_context_iter();
                                                                                while let Some(v1559) = v1558.next(ctx) {
                                                                                    let v1560 = C::iconst_sextend_etor(ctx, v1559);
                                                                                    if let Some(v1561) = v1560 {
                                                                                        let v1572 = C::i64_gt_eq(ctx, v1561.1, 0_i64);
                                                                                        if v1572 == true {
                                                                                            let mut v1564 = C::inst_data_value_tupled_etor_returns::default();
                                                                                            C::inst_data_value_tupled_etor(ctx, v758.0, &mut v1564);
                                                                                            let mut v1564 = v1564.into_context_iter();
                                                                                            while let Some(v1565) = v1564.next(ctx) {
                                                                                                let v1566 = C::iconst_sextend_etor(ctx, v1565);
                                                                                                if let Some(v1567) = v1566 {
                                                                                                    if v1561.1 == v1567.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 v343 = C::ty_int_vec128(ctx, v2.0);
                                                                        if let Some(v344) = v343 {
                                                                            if v11.0 == v344 {
                                                                                let v752 = C::unpack_value_array_2(ctx, v750);
                                                                                let v758 = C::unpack_value_array_2(ctx, v756);
                                                                                if v752.0 == v758.0 {
                                                                                    if v752.1 == v758.1 {
                                                                                        let v347 = constructor_iconst_u(ctx, v344, 0x0_u64);
                                                                                        // Rule at src/opts/icmp.isle line 321.
                                                                                        returns.extend(Some(v347));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                            &IntCC::UnsignedLessThan => {
                                                                match v757 {
                                                                    &IntCC::NotEqual => {
                                                                        if v2.0 == v11.0 {
                                                                            let v752 = C::unpack_value_array_2(ctx, v750);
                                                                            let v758 = C::unpack_value_array_2(ctx, v756);
                                                                            if v752.0 == v758.0 {
                                                                                let mut v1551 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v758.1, &mut v1551);
                                                                                let mut v1551 = v1551.into_context_iter();
                                                                                while let Some(v1552) = v1551.next(ctx) {
                                                                                    let v1553 = C::iconst_sextend_etor(ctx, v1552);
                                                                                    if let Some(v1554) = v1553 {
                                                                                        if v1554.1 == -1_i64 {
                                                                                            let v1578 = constructor_ult(ctx, v2.0, v752.0, v752.1);
                                                                                            // Rule at src/opts/icmp.isle line 376.
                                                                                            returns.extend(Some(v1578));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            if v752.0 == v758.1 {
                                                                                let mut v1564 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v758.0, &mut v1564);
                                                                                let mut v1564 = v1564.into_context_iter();
                                                                                while let Some(v1565) = v1564.next(ctx) {
                                                                                    let v1566 = C::iconst_sextend_etor(ctx, v1565);
                                                                                    if let Some(v1567) = v1566 {
                                                                                        if v1567.1 == -1_i64 {
                                                                                            let v1578 = constructor_ult(ctx, v2.0, v752.0, v752.1);
                                                                                            // Rule at src/opts/icmp.isle line 379.
                                                                                            returns.extend(Some(v1578));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedGreaterThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v752 = C::unpack_value_array_2(ctx, v750);
                                                                            let v758 = C::unpack_value_array_2(ctx, v756);
                                                                            if v752.0 == v758.0 {
                                                                                let mut v1545 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v752.1, &mut v1545);
                                                                                let mut v1545 = v1545.into_context_iter();
                                                                                while let Some(v1546) = v1545.next(ctx) {
                                                                                    let v1547 = C::iconst_sextend_etor(ctx, v1546);
                                                                                    if let Some(v1548) = v1547 {
                                                                                        let v1557 = C::i64_gt_eq(ctx, v1548.1, 0_i64);
                                                                                        if v1557 == true {
                                                                                            let mut v1551 = C::inst_data_value_tupled_etor_returns::default();
                                                                                            C::inst_data_value_tupled_etor(ctx, v758.1, &mut v1551);
                                                                                            let mut v1551 = v1551.into_context_iter();
                                                                                            while let Some(v1552) = v1551.next(ctx) {
                                                                                                let v1553 = C::iconst_sextend_etor(ctx, v1552);
                                                                                                if let Some(v1554) = v1553 {
                                                                                                    if v1548.1 == v1554.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 v752.1 == v758.1 {
                                                                                let mut v1558 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v752.0, &mut v1558);
                                                                                let mut v1558 = v1558.into_context_iter();
                                                                                while let Some(v1559) = v1558.next(ctx) {
                                                                                    let v1560 = C::iconst_sextend_etor(ctx, v1559);
                                                                                    if let Some(v1561) = v1560 {
                                                                                        let v1570 = C::i64_lt(ctx, v1561.1, 0_i64);
                                                                                        if v1570 == true {
                                                                                            let mut v1564 = C::inst_data_value_tupled_etor_returns::default();
                                                                                            C::inst_data_value_tupled_etor(ctx, v758.0, &mut v1564);
                                                                                            let mut v1564 = v1564.into_context_iter();
                                                                                            while let Some(v1565) = v1564.next(ctx) {
                                                                                                let v1566 = C::iconst_sextend_etor(ctx, v1565);
                                                                                                if let Some(v1567) = v1566 {
                                                                                                    if v1561.1 == v1567.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 v343 = C::ty_int_vec128(ctx, v2.0);
                                                                        if let Some(v344) = v343 {
                                                                            if v11.0 == v344 {
                                                                                let v752 = C::unpack_value_array_2(ctx, v750);
                                                                                let v758 = C::unpack_value_array_2(ctx, v756);
                                                                                if v752.0 == v758.0 {
                                                                                    if v752.1 == v758.1 {
                                                                                        let v347 = constructor_iconst_u(ctx, v344, 0x0_u64);
                                                                                        // Rule at src/opts/icmp.isle line 322.
                                                                                        returns.extend(Some(v347));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                        let v334 = C::fits_in_64(ctx, v2.0);
                                                        if let Some(v335) = v334 {
                                                            if v11.0 == v335 {
                                                                let v1465 = constructor_intcc_comparable(ctx, v751, v757);
                                                                if let Some(v1466) = v1465 {
                                                                    let v752 = C::unpack_value_array_2(ctx, v750);
                                                                    let v758 = C::unpack_value_array_2(ctx, v756);
                                                                    if v752.0 == v758.0 {
                                                                        if v752.1 == v758.1 {
                                                                            let v1467 = constructor_decompose_intcc(ctx, v751);
                                                                            let v1468 = constructor_decompose_intcc(ctx, v757);
                                                                            let v1469 = C::u64_and(ctx, v1467, v1468);
                                                                            let v1470 = constructor_compose_icmp(ctx, v335, v1469, v1466, v752.0, v752.1);
                                                                            // Rule at src/opts/icmp.isle line 179.
                                                                            returns.extend(Some(v1470));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v26,
                                    arg: v27,
                                } => {
                                    match v26 {
                                        &Opcode::Splat => {
                                            let v1985 = C::ty_vector_not_float(ctx, v2.0);
                                            if let Some(v1986) = v1985 {
                                                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 v1849 = C::lane_type(ctx, v2.0);
                                                                    let v1987 = constructor_band(ctx, v1849, v30, v27);
                                                                    let v1988 = constructor_splat(ctx, v2.0, v1987);
                                                                    // Rule at src/opts/vector.isle line 14.
                                                                    returns.extend(Some(v1988));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Bnot => {
                                            if v2.0 == v11.0 {
                                                let mut v639 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v27, &mut v639);
                                                let mut v639 = v639.into_context_iter();
                                                while let Some(v640) = v639.next(ctx) {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v643,
                                                        args: ref v644,
                                                    } = &v640.1 {
                                                        match v643 {
                                                            &Opcode::Band => {
                                                                if v2.0 == v640.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 v97,
                                                                            args: ref v98,
                                                                        } = &v19.1 {
                                                                            if let &Opcode::Bor = v97 {
                                                                                if v2.0 == v19.0 {
                                                                                    let v99 = C::unpack_value_array_2(ctx, v98);
                                                                                    let mut v102 = C::inst_data_value_etor_returns::default();
                                                                                    C::inst_data_value_etor(ctx, v99.0, &mut v102);
                                                                                    let mut v102 = v102.into_context_iter();
                                                                                    while let Some(v103) = v102.next(ctx) {
                                                                                        if let &InstructionData::Unary {
                                                                                            opcode: ref v106,
                                                                                            arg: v107,
                                                                                        } = &v103.1 {
                                                                                            if let &Opcode::Bnot = v106 {
                                                                                                if v2.0 == v103.0 {
                                                                                                    let v645 = C::unpack_value_array_2(ctx, v644);
                                                                                                    if v99.1 == v645.0 {
                                                                                                        if v107 == v645.1 {
                                                                                                            let v925 = constructor_bnot(ctx, v2.0, v107);
                                                                                                            // Rule at src/opts/bitops.isle line 663.
                                                                                                            returns.extend(Some(v925));
                                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                        }
                                                                                                    }
                                                                                                    if v107 == v645.0 {
                                                                                                        if v99.1 == v645.1 {
                                                                                                            let v925 = constructor_bnot(ctx, v2.0, v107);
                                                                                                            // Rule at src/opts/bitops.isle line 661.
                                                                                                            returns.extend(Some(v925));
                                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                    let mut v109 = C::inst_data_value_etor_returns::default();
                                                                                    C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                                                    let mut v109 = v109.into_context_iter();
                                                                                    while let Some(v110) = v109.next(ctx) {
                                                                                        if let &InstructionData::Unary {
                                                                                            opcode: ref v113,
                                                                                            arg: v114,
                                                                                        } = &v110.1 {
                                                                                            if let &Opcode::Bnot = v113 {
                                                                                                if v2.0 == v110.0 {
                                                                                                    let v645 = C::unpack_value_array_2(ctx, v644);
                                                                                                    if v99.0 == v645.0 {
                                                                                                        if v114 == v645.1 {
                                                                                                            let v926 = constructor_bnot(ctx, v2.0, v114);
                                                                                                            // Rule at src/opts/bitops.isle line 667.
                                                                                                            returns.extend(Some(v926));
                                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                        }
                                                                                                    }
                                                                                                    if v114 == v645.0 {
                                                                                                        if v99.0 == v645.1 {
                                                                                                            let v926 = constructor_bnot(ctx, v2.0, v114);
                                                                                                            // Rule at src/opts/bitops.isle line 665.
                                                                                                            returns.extend(Some(v926));
                                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    let v645 = C::unpack_value_array_2(ctx, v644);
                                                                    if v7.0 == v645.0 {
                                                                        let v736 = constructor_bnot(ctx, v2.0, v645.1);
                                                                        let v742 = constructor_band(ctx, v2.0, v7.0, v736);
                                                                        // Rule at src/opts/bitops.isle line 321.
                                                                        returns.extend(Some(v742));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v7.0 == v645.1 {
                                                                        let v732 = constructor_bnot(ctx, v2.0, v645.0);
                                                                        let v740 = constructor_band(ctx, v2.0, v7.0, v732);
                                                                        // Rule at src/opts/bitops.isle line 319.
                                                                        returns.extend(Some(v740));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Bxor => {
                                                                if v2.0 == v640.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 v97,
                                                                            args: ref v98,
                                                                        } = &v19.1 {
                                                                            if let &Opcode::Bor = v97 {
                                                                                if v2.0 == v19.0 {
                                                                                    let v99 = C::unpack_value_array_2(ctx, v98);
                                                                                    let v645 = C::unpack_value_array_2(ctx, v644);
                                                                                    if v99.0 == v645.0 {
                                                                                        if v99.1 == v645.1 {
                                                                                            let v138 = constructor_band(ctx, v2.0, v99.0, v99.1);
                                                                                            // Rule at src/opts/bitops.isle line 580.
                                                                                            returns.extend(Some(v138));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            let v242 = constructor_band(ctx, v2.0, v99.1, v99.0);
                                                                                            // Rule at src/opts/bitops.isle line 586.
                                                                                            returns.extend(Some(v242));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                    if v99.0 == v645.1 {
                                                                                        if v99.1 == v645.0 {
                                                                                            let v138 = constructor_band(ctx, v2.0, v99.0, v99.1);
                                                                                            // Rule at src/opts/bitops.isle line 582.
                                                                                            returns.extend(Some(v138));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            let v242 = constructor_band(ctx, v2.0, v99.1, v99.0);
                                                                                            // Rule at src/opts/bitops.isle line 584.
                                                                                            returns.extend(Some(v242));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    let v645 = C::unpack_value_array_2(ctx, v644);
                                                                    if v7.0 == v645.0 {
                                                                        let v888 = constructor_band(ctx, v2.0, v7.0, v645.1);
                                                                        // Rule at src/opts/bitops.isle line 602.
                                                                        returns.extend(Some(v888));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v7.0 == v645.1 {
                                                                        let v889 = constructor_band(ctx, v2.0, v7.0, v645.0);
                                                                        // Rule at src/opts/bitops.isle line 604.
                                                                        returns.extend(Some(v889));
                                                                        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 v700 = constructor_bor(ctx, v2.0, v30, v27);
                                                                let v701 = constructor_bnot(ctx, v2.0, v700);
                                                                // Rule at src/opts/bitops.isle line 285.
                                                                returns.extend(Some(v701));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                let v702 = constructor_bor(ctx, v2.0, v27, v30);
                                                                let v703 = constructor_bnot(ctx, v2.0, v702);
                                                                // Rule at src/opts/bitops.isle line 286.
                                                                returns.extend(Some(v703));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            let v343 = C::ty_int_vec128(ctx, v2.0);
                                            if let Some(v344) = v343 {
                                                if v11.0 == v344 {
                                                    if v7.0 == v27 {
                                                        let v347 = constructor_iconst_u(ctx, v344, 0x0_u64);
                                                        let v348 = C::subsume(ctx, v347);
                                                        // Rule at src/opts/bitops.isle line 34.
                                                        returns.extend(Some(v348));
                                                        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 v1342 = C::value_type(ctx, v30);
                                                        let v1373 = C::value_type(ctx, v27);
                                                        if v1342 == v1373 {
                                                            let v1374 = constructor_band(ctx, v1342, v30, v27);
                                                            let v1375 = constructor_uextend(ctx, v2.0, v1374);
                                                            // Rule at src/opts/extends.isle line 70.
                                                            returns.extend(Some(v1375));
                                                            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 v97,
                                                    args: ref v98,
                                                } => {
                                                    if let &Opcode::Band = v97 {
                                                        if v2.0 == v11.0 {
                                                            if v2.0 == v19.0 {
                                                                let v99 = C::unpack_value_array_2(ctx, v98);
                                                                let mut v109 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                                let mut v109 = v109.into_context_iter();
                                                                while let Some(v110) = v109.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v127,
                                                                        imm: v128,
                                                                    } = &v110.1 {
                                                                        if let &Opcode::Iconst = v127 {
                                                                            if v2.0 == v110.0 {
                                                                                let v1053 = constructor_band(ctx, v2.0, v99.1, v7.1);
                                                                                let v1054 = constructor_band(ctx, v2.0, v99.0, v1053);
                                                                                // Rule at src/opts/cprop.isle line 219.
                                                                                returns.extend(Some(v1054));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                &InstructionData::IntCompare {
                                                    opcode: ref v749,
                                                    args: ref v750,
                                                    cond: ref v751,
                                                } => {
                                                    if let &Opcode::Icmp = v749 {
                                                        let v16 = C::u64_from_imm64(ctx, v15);
                                                        if v16 == 0x1_u64 {
                                                            let v339 = C::ty_int(ctx, v2.0);
                                                            if let Some(v340) = v339 {
                                                                // 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 v339 = C::ty_int(ctx, v2.0);
                                                                if let Some(v340) = v339 {
                                                                    let mut v649 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v30, &mut v649);
                                                                    let mut v649 = v649.into_context_iter();
                                                                    while let Some(v650) = v649.next(ctx) {
                                                                        if let &InstructionData::IntCompare {
                                                                            opcode: ref v1444,
                                                                            args: ref v1445,
                                                                            cond: ref v1446,
                                                                        } = &v650.1 {
                                                                            if let &Opcode::Icmp = v1444 {
                                                                                // Rule at src/opts/icmp.isle line 95.
                                                                                returns.extend(Some(v7.0));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            let v1342 = C::value_type(ctx, v30);
                                                            let v1343 = C::ty_mask(ctx, v1342);
                                                            let v1344 = C::u64_and(ctx, v16, v1343);
                                                            let v1345 = C::u64_eq(ctx, v1343, v1344);
                                                            if v1345 == 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 v1342 = C::value_type(ctx, v30);
                                                            let v1343 = C::ty_mask(ctx, v1342);
                                                            let v1346 = C::u64_eq(ctx, v16, v1343);
                                                            if v1346 == true {
                                                                let v1347 = constructor_uextend(ctx, v2.0, v30);
                                                                // Rule at src/opts/extends.isle line 22.
                                                                returns.extend(Some(v1347));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                &InstructionData::UnaryImm {
                                                    opcode: ref v22,
                                                    imm: v23,
                                                } => {
                                                    if let &Opcode::Iconst = v22 {
                                                        let v334 = C::fits_in_64(ctx, v2.0);
                                                        if let Some(v335) = v334 {
                                                            if v11.0 == v19.0 {
                                                                if v11.0 == v335 {
                                                                    let v964 = C::imm64_and(ctx, v335, v23, v15);
                                                                    let v965 = constructor_iconst(ctx, v335, v964);
                                                                    let v966 = C::subsume(ctx, v965);
                                                                    // Rule at src/opts/cprop.isle line 61.
                                                                    returns.extend(Some(v966));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                _ => {}
                                            }
                                        }
                                        let v16 = C::u64_from_imm64(ctx, v15);
                                        if v16 == 0x0_u64 {
                                            let v343 = C::ty_int_vec128(ctx, v2.0);
                                            if let Some(v344) = v343 {
                                                if v11.0 == v344 {
                                                    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 v1605 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 13.
                                        returns.extend(Some(v1605));
                                        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 v97,
                                    args: ref v98,
                                } => {
                                    match v97 {
                                        &Opcode::Band => {
                                            if v2.0 == v19.0 {
                                                let v99 = C::unpack_value_array_2(ctx, v98);
                                                if v7.1 == v99.0 {
                                                    let v138 = constructor_band(ctx, v2.0, v99.0, v99.1);
                                                    // Rule at src/opts/bitops.isle line 192.
                                                    returns.extend(Some(v138));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.1 == v99.1 {
                                                    let v138 = constructor_band(ctx, v2.0, v99.0, v99.1);
                                                    // Rule at src/opts/bitops.isle line 193.
                                                    returns.extend(Some(v138));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        &Opcode::Bor => {
                                            if v2.0 == v19.0 {
                                                let v99 = C::unpack_value_array_2(ctx, v98);
                                                let mut v102 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v99.0, &mut v102);
                                                let mut v102 = v102.into_context_iter();
                                                while let Some(v103) = v102.next(ctx) {
                                                    match &v103.1 {
                                                        &InstructionData::Binary {
                                                            opcode: ref v284,
                                                            args: ref v285,
                                                        } => {
                                                            if let &Opcode::Band = v284 {
                                                                if v2.0 == v103.0 {
                                                                    let v286 = C::unpack_value_array_2(ctx, v285);
                                                                    if v7.1 == v286.0 {
                                                                        let v850 = constructor_bor(ctx, v2.0, v99.1, v286.1);
                                                                        let v851 = constructor_band(ctx, v2.0, v850, v286.0);
                                                                        // Rule at src/opts/bitops.isle line 508.
                                                                        returns.extend(Some(v851));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v7.1 == v286.1 {
                                                                        let v858 = constructor_bor(ctx, v2.0, v99.1, v286.0);
                                                                        let v859 = constructor_band(ctx, v2.0, v858, v286.1);
                                                                        // Rule at src/opts/bitops.isle line 512.
                                                                        returns.extend(Some(v859));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v106,
                                                            arg: v107,
                                                        } => {
                                                            if let &Opcode::Bnot = v106 {
                                                                if v7.1 == v107 {
                                                                    if v2.0 == v103.0 {
                                                                        let v863 = constructor_band(ctx, v2.0, v107, v99.1);
                                                                        // Rule at src/opts/bitops.isle line 527.
                                                                        returns.extend(Some(v863));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let mut v109 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                let mut v109 = v109.into_context_iter();
                                                while let Some(v110) = v109.next(ctx) {
                                                    match &v110.1 {
                                                        &InstructionData::Binary {
                                                            opcode: ref v268,
                                                            args: ref v269,
                                                        } => {
                                                            if let &Opcode::Band = v268 {
                                                                if v2.0 == v110.0 {
                                                                    let v270 = C::unpack_value_array_2(ctx, v269);
                                                                    if v7.1 == v270.0 {
                                                                        let v846 = constructor_bor(ctx, v2.0, v99.0, v270.1);
                                                                        let v847 = constructor_band(ctx, v2.0, v846, v270.0);
                                                                        // Rule at src/opts/bitops.isle line 506.
                                                                        returns.extend(Some(v847));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v7.1 == v270.1 {
                                                                        let v854 = constructor_bor(ctx, v2.0, v99.0, v270.0);
                                                                        let v855 = constructor_band(ctx, v2.0, v854, v270.1);
                                                                        // Rule at src/opts/bitops.isle line 510.
                                                                        returns.extend(Some(v855));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v113,
                                                            arg: v114,
                                                        } => {
                                                            if let &Opcode::Bnot = v113 {
                                                                if v7.1 == v114 {
                                                                    if v2.0 == v110.0 {
                                                                        let v865 = constructor_band(ctx, v2.0, v114, v99.0);
                                                                        // Rule at src/opts/bitops.isle line 529.
                                                                        returns.extend(Some(v865));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                if v7.1 == v99.0 {
                                                    // Rule at src/opts/bitops.isle line 249.
                                                    returns.extend(Some(v99.0));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.1 == v99.1 {
                                                    // Rule at src/opts/bitops.isle line 251.
                                                    returns.extend(Some(v99.1));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        &Opcode::Bxor => {
                                            if v2.0 == v19.0 {
                                                let v99 = C::unpack_value_array_2(ctx, v98);
                                                let mut v102 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v99.0, &mut v102);
                                                let mut v102 = v102.into_context_iter();
                                                while let Some(v103) = v102.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v106,
                                                        arg: v107,
                                                    } = &v103.1 {
                                                        if let &Opcode::Bnot = v106 {
                                                            if v2.0 == v103.0 {
                                                                if v7.1 == v107 {
                                                                    let v863 = constructor_band(ctx, v2.0, v107, v99.1);
                                                                    // Rule at src/opts/bitops.isle line 609.
                                                                    returns.extend(Some(v863));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v7.1 == v99.1 {
                                                                    let v626 = constructor_band(ctx, v2.0, v99.1, v107);
                                                                    // Rule at src/opts/bitops.isle line 199.
                                                                    returns.extend(Some(v626));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                let mut v109 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                let mut v109 = v109.into_context_iter();
                                                while let Some(v110) = v109.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v113,
                                                        arg: v114,
                                                    } = &v110.1 {
                                                        if let &Opcode::Bnot = v113 {
                                                            if v2.0 == v110.0 {
                                                                if v7.1 == v99.0 {
                                                                    let v625 = constructor_band(ctx, v2.0, v99.0, v114);
                                                                    // Rule at src/opts/bitops.isle line 198.
                                                                    returns.extend(Some(v625));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v7.1 == v114 {
                                                                    let v865 = constructor_band(ctx, v2.0, v114, v99.0);
                                                                    // Rule at src/opts/bitops.isle line 611.
                                                                    returns.extend(Some(v865));
                                                                    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 v649 = C::inst_data_value_etor_returns::default();
                                            C::inst_data_value_etor(ctx, v30, &mut v649);
                                            let mut v649 = v649.into_context_iter();
                                            while let Some(v650) = v649.next(ctx) {
                                                if let &InstructionData::Binary {
                                                    opcode: ref v653,
                                                    args: ref v654,
                                                } = &v650.1 {
                                                    match v653 {
                                                        &Opcode::Band => {
                                                            if v2.0 == v650.0 {
                                                                let v655 = C::unpack_value_array_2(ctx, v654);
                                                                if v7.1 == v655.0 {
                                                                    let v738 = constructor_bnot(ctx, v2.0, v655.1);
                                                                    let v743 = constructor_band(ctx, v2.0, v655.0, v738);
                                                                    // Rule at src/opts/bitops.isle line 322.
                                                                    returns.extend(Some(v743));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v7.1 == v655.1 {
                                                                    let v734 = constructor_bnot(ctx, v2.0, v655.0);
                                                                    let v741 = constructor_band(ctx, v2.0, v655.1, v734);
                                                                    // Rule at src/opts/bitops.isle line 320.
                                                                    returns.extend(Some(v741));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                        &Opcode::Bxor => {
                                                            if v2.0 == v650.0 {
                                                                let v655 = C::unpack_value_array_2(ctx, v654);
                                                                if v7.1 == v655.0 {
                                                                    let v882 = constructor_band(ctx, v2.0, v655.0, v655.1);
                                                                    // Rule at src/opts/bitops.isle line 603.
                                                                    returns.extend(Some(v882));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v7.1 == v655.1 {
                                                                    let v883 = constructor_band(ctx, v2.0, v655.1, v655.0);
                                                                    // Rule at src/opts/bitops.isle line 605.
                                                                    returns.extend(Some(v883));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                            }
                                        }
                                        if v7.1 == v30 {
                                            let v343 = C::ty_int_vec128(ctx, v2.0);
                                            if let Some(v344) = v343 {
                                                if v19.0 == v344 {
                                                    let v347 = constructor_iconst_u(ctx, v344, 0x0_u64);
                                                    let v348 = C::subsume(ctx, v347);
                                                    // Rule at src/opts/bitops.isle line 35.
                                                    returns.extend(Some(v348));
                                                    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_band(ctx, v2.0, v7.1, v7.0);
                                            // Rule at src/opts/cprop.isle line 161.
                                            returns.extend(Some(v1024));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        let v1605 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 11.
                                        returns.extend(Some(v1605));
                                        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 v133,
                                    args: ref v134,
                                } => {
                                    match v133 {
                                        &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 v97,
                                                            args: ref v98,
                                                        } => {
                                                            match v97 {
                                                                &Opcode::Band => {
                                                                    if v2.0 == v19.0 {
                                                                        let v99 = C::unpack_value_array_2(ctx, v98);
                                                                        let mut v102 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v99.0, &mut v102);
                                                                        let mut v102 = v102.into_context_iter();
                                                                        while let Some(v103) = v102.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v106,
                                                                                arg: v107,
                                                                            } = &v103.1 {
                                                                                if let &Opcode::Bnot = v106 {
                                                                                    if v2.0 == v103.0 {
                                                                                        let v135 = C::unpack_value_array_2(ctx, v134);
                                                                                        if v107 == v135.0 {
                                                                                            let mut v258 = C::inst_data_value_etor_returns::default();
                                                                                            C::inst_data_value_etor(ctx, v135.1, &mut v258);
                                                                                            let mut v258 = v258.into_context_iter();
                                                                                            while let Some(v259) = v258.next(ctx) {
                                                                                                if let &InstructionData::Unary {
                                                                                                    opcode: ref v627,
                                                                                                    arg: v628,
                                                                                                } = &v259.1 {
                                                                                                    if let &Opcode::Bnot = v627 {
                                                                                                        if v2.0 == v259.0 {
                                                                                                            if v99.1 == v628 {
                                                                                                                let v874 = constructor_bxor(ctx, v2.0, v107, v99.1);
                                                                                                                // Rule at src/opts/bitops.isle line 549.
                                                                                                                returns.extend(Some(v874));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                let v870 = constructor_bxor(ctx, v2.0, v99.1, v107);
                                                                                                                // Rule at src/opts/bitops.isle line 554.
                                                                                                                returns.extend(Some(v870));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                            if v99.1 == v135.1 {
                                                                                                // Rule at src/opts/bitops.isle line 471.
                                                                                                returns.extend(Some(v99.1));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                        if v107 == v135.1 {
                                                                                            let mut v274 = C::inst_data_value_etor_returns::default();
                                                                                            C::inst_data_value_etor(ctx, v135.0, &mut v274);
                                                                                            let mut v274 = v274.into_context_iter();
                                                                                            while let Some(v275) = v274.next(ctx) {
                                                                                                if let &InstructionData::Unary {
                                                                                                    opcode: ref v630,
                                                                                                    arg: v631,
                                                                                                } = &v275.1 {
                                                                                                    if let &Opcode::Bnot = v630 {
                                                                                                        if v2.0 == v275.0 {
                                                                                                            if v99.1 == v631 {
                                                                                                                let v870 = constructor_bxor(ctx, v2.0, v99.1, v107);
                                                                                                                // Rule at src/opts/bitops.isle line 552.
                                                                                                                returns.extend(Some(v870));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                let v874 = constructor_bxor(ctx, v2.0, v107, v99.1);
                                                                                                                // Rule at src/opts/bitops.isle line 553.
                                                                                                                returns.extend(Some(v874));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                            if v99.1 == v135.0 {
                                                                                                // Rule at src/opts/bitops.isle line 467.
                                                                                                returns.extend(Some(v99.1));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let mut v109 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                                        let mut v109 = v109.into_context_iter();
                                                                        while let Some(v110) = v109.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v113,
                                                                                arg: v114,
                                                                            } = &v110.1 {
                                                                                if let &Opcode::Bnot = v113 {
                                                                                    if v2.0 == v110.0 {
                                                                                        let v135 = C::unpack_value_array_2(ctx, v134);
                                                                                        if v114 == v135.0 {
                                                                                            let mut v258 = C::inst_data_value_etor_returns::default();
                                                                                            C::inst_data_value_etor(ctx, v135.1, &mut v258);
                                                                                            let mut v258 = v258.into_context_iter();
                                                                                            while let Some(v259) = v258.next(ctx) {
                                                                                                if let &InstructionData::Unary {
                                                                                                    opcode: ref v627,
                                                                                                    arg: v628,
                                                                                                } = &v259.1 {
                                                                                                    if let &Opcode::Bnot = v627 {
                                                                                                        if v99.0 == v628 {
                                                                                                            if v2.0 == v259.0 {
                                                                                                                let v868 = constructor_bxor(ctx, v2.0, v99.0, v114);
                                                                                                                // Rule at src/opts/bitops.isle line 550.
                                                                                                                returns.extend(Some(v868));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                let v875 = constructor_bxor(ctx, v2.0, v114, v99.0);
                                                                                                                // Rule at src/opts/bitops.isle line 551.
                                                                                                                returns.extend(Some(v875));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                            if v99.0 == v135.1 {
                                                                                                // Rule at src/opts/bitops.isle line 469.
                                                                                                returns.extend(Some(v99.0));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                        if v114 == v135.1 {
                                                                                            let mut v274 = C::inst_data_value_etor_returns::default();
                                                                                            C::inst_data_value_etor(ctx, v135.0, &mut v274);
                                                                                            let mut v274 = v274.into_context_iter();
                                                                                            while let Some(v275) = v274.next(ctx) {
                                                                                                if let &InstructionData::Unary {
                                                                                                    opcode: ref v630,
                                                                                                    arg: v631,
                                                                                                } = &v275.1 {
                                                                                                    if let &Opcode::Bnot = v630 {
                                                                                                        if v99.0 == v631 {
                                                                                                            if v2.0 == v275.0 {
                                                                                                                let v868 = constructor_bxor(ctx, v2.0, v99.0, v114);
                                                                                                                // Rule at src/opts/bitops.isle line 548.
                                                                                                                returns.extend(Some(v868));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                let v875 = constructor_bxor(ctx, v2.0, v114, v99.0);
                                                                                                                // Rule at src/opts/bitops.isle line 555.
                                                                                                                returns.extend(Some(v875));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                            if v99.0 == v135.0 {
                                                                                                // Rule at src/opts/bitops.isle line 465.
                                                                                                returns.extend(Some(v99.0));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let v135 = C::unpack_value_array_2(ctx, v134);
                                                                        if v99.0 == v135.0 {
                                                                            let mut v258 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v135.1, &mut v258);
                                                                            let mut v258 = v258.into_context_iter();
                                                                            while let Some(v259) = v258.next(ctx) {
                                                                                if let &InstructionData::Unary {
                                                                                    opcode: ref v627,
                                                                                    arg: v628,
                                                                                } = &v259.1 {
                                                                                    if let &Opcode::Bnot = v627 {
                                                                                        if v99.1 == v628 {
                                                                                            if v2.0 == v259.0 {
                                                                                                // Rule at src/opts/bitops.isle line 464.
                                                                                                returns.extend(Some(v99.0));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            let v696 = constructor_bor(ctx, v2.0, v99.1, v135.1);
                                                                            let v697 = constructor_band(ctx, v2.0, v696, v99.0);
                                                                            // Rule at src/opts/bitops.isle line 271.
                                                                            returns.extend(Some(v697));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            let v698 = constructor_bor(ctx, v2.0, v135.1, v99.1);
                                                                            let v699 = constructor_band(ctx, v2.0, v698, v99.0);
                                                                            // Rule at src/opts/bitops.isle line 272.
                                                                            returns.extend(Some(v699));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v99.1 == v135.0 {
                                                                            let mut v258 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v135.1, &mut v258);
                                                                            let mut v258 = v258.into_context_iter();
                                                                            while let Some(v259) = v258.next(ctx) {
                                                                                if let &InstructionData::Unary {
                                                                                    opcode: ref v627,
                                                                                    arg: v628,
                                                                                } = &v259.1 {
                                                                                    if let &Opcode::Bnot = v627 {
                                                                                        if v99.0 == v628 {
                                                                                            if v2.0 == v259.0 {
                                                                                                // Rule at src/opts/bitops.isle line 468.
                                                                                                returns.extend(Some(v99.1));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            let v688 = constructor_bor(ctx, v2.0, v99.0, v135.1);
                                                                            let v689 = constructor_band(ctx, v2.0, v688, v99.1);
                                                                            // Rule at src/opts/bitops.isle line 267.
                                                                            returns.extend(Some(v689));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            let v694 = constructor_bor(ctx, v2.0, v135.1, v99.0);
                                                                            let v695 = constructor_band(ctx, v2.0, v694, v99.1);
                                                                            // Rule at src/opts/bitops.isle line 270.
                                                                            returns.extend(Some(v695));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v99.0 == v135.1 {
                                                                            let mut v274 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v135.0, &mut v274);
                                                                            let mut v274 = v274.into_context_iter();
                                                                            while let Some(v275) = v274.next(ctx) {
                                                                                if let &InstructionData::Unary {
                                                                                    opcode: ref v630,
                                                                                    arg: v631,
                                                                                } = &v275.1 {
                                                                                    if let &Opcode::Bnot = v630 {
                                                                                        if v99.1 == v631 {
                                                                                            if v2.0 == v275.0 {
                                                                                                // Rule at src/opts/bitops.isle line 466.
                                                                                                returns.extend(Some(v99.0));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            let v690 = constructor_bor(ctx, v2.0, v135.0, v99.1);
                                                                            let v691 = constructor_band(ctx, v2.0, v690, v99.0);
                                                                            // Rule at src/opts/bitops.isle line 268.
                                                                            returns.extend(Some(v691));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            let v692 = constructor_bor(ctx, v2.0, v99.1, v135.0);
                                                                            let v693 = constructor_band(ctx, v2.0, v692, v99.0);
                                                                            // Rule at src/opts/bitops.isle line 269.
                                                                            returns.extend(Some(v693));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v99.1 == v135.1 {
                                                                            let mut v274 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v135.0, &mut v274);
                                                                            let mut v274 = v274.into_context_iter();
                                                                            while let Some(v275) = v274.next(ctx) {
                                                                                if let &InstructionData::Unary {
                                                                                    opcode: ref v630,
                                                                                    arg: v631,
                                                                                } = &v275.1 {
                                                                                    if let &Opcode::Bnot = v630 {
                                                                                        if v99.0 == v631 {
                                                                                            if v2.0 == v275.0 {
                                                                                                // Rule at src/opts/bitops.isle line 470.
                                                                                                returns.extend(Some(v99.1));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            let v684 = constructor_bor(ctx, v2.0, v99.0, v135.0);
                                                                            let v685 = constructor_band(ctx, v2.0, v684, v99.1);
                                                                            // Rule at src/opts/bitops.isle line 265.
                                                                            returns.extend(Some(v685));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            let v686 = constructor_bor(ctx, v2.0, v135.0, v99.0);
                                                                            let v687 = constructor_band(ctx, v2.0, v686, v99.1);
                                                                            // Rule at src/opts/bitops.isle line 266.
                                                                            returns.extend(Some(v687));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Bxor => {
                                                                    if v2.0 == v19.0 {
                                                                        let v135 = C::unpack_value_array_2(ctx, v134);
                                                                        let mut v258 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v135.1, &mut v258);
                                                                        let mut v258 = v258.into_context_iter();
                                                                        while let Some(v259) = v258.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v627,
                                                                                arg: v628,
                                                                            } = &v259.1 {
                                                                                if let &Opcode::Bnot = v627 {
                                                                                    if v2.0 == v259.0 {
                                                                                        let v99 = C::unpack_value_array_2(ctx, v98);
                                                                                        if v99.0 == v135.0 {
                                                                                            if v99.1 == v628 {
                                                                                                let v238 = constructor_bxor(ctx, v2.0, v99.0, v99.1);
                                                                                                // Rule at src/opts/bitops.isle line 559.
                                                                                                returns.extend(Some(v238));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                        if v99.0 == v628 {
                                                                                            if v99.1 == v135.0 {
                                                                                                let v239 = constructor_bxor(ctx, v2.0, v99.1, v99.0);
                                                                                                // Rule at src/opts/bitops.isle line 561.
                                                                                                returns.extend(Some(v239));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let mut v274 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v135.0, &mut v274);
                                                                        let mut v274 = v274.into_context_iter();
                                                                        while let Some(v275) = v274.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v630,
                                                                                arg: v631,
                                                                            } = &v275.1 {
                                                                                if let &Opcode::Bnot = v630 {
                                                                                    if v2.0 == v275.0 {
                                                                                        let v99 = C::unpack_value_array_2(ctx, v98);
                                                                                        if v99.0 == v135.1 {
                                                                                            if v99.1 == v631 {
                                                                                                let v238 = constructor_bxor(ctx, v2.0, v99.0, v99.1);
                                                                                                // Rule at src/opts/bitops.isle line 563.
                                                                                                returns.extend(Some(v238));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                        if v99.0 == v631 {
                                                                                            if v99.1 == v135.1 {
                                                                                                let v239 = constructor_bxor(ctx, v2.0, v99.1, v99.0);
                                                                                                // Rule at src/opts/bitops.isle line 565.
                                                                                                returns.extend(Some(v239));
                                                                                                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 v649 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v30, &mut v649);
                                                                    let mut v649 = v649.into_context_iter();
                                                                    while let Some(v650) = v649.next(ctx) {
                                                                        if let &InstructionData::Binary {
                                                                            opcode: ref v653,
                                                                            args: ref v654,
                                                                        } = &v650.1 {
                                                                            match v653 {
                                                                                &Opcode::Bor => {
                                                                                    if v2.0 == v650.0 {
                                                                                        let v135 = C::unpack_value_array_2(ctx, v134);
                                                                                        let v655 = C::unpack_value_array_2(ctx, v654);
                                                                                        if v135.0 == v655.0 {
                                                                                            if v135.1 == v655.1 {
                                                                                                let v658 = constructor_bxor(ctx, v2.0, v655.0, v655.1);
                                                                                                let v659 = constructor_bnot(ctx, v2.0, v658);
                                                                                                // Rule at src/opts/bitops.isle line 672.
                                                                                                returns.extend(Some(v659));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v660 = constructor_bxor(ctx, v2.0, v655.1, v655.0);
                                                                                                let v661 = constructor_bnot(ctx, v2.0, v660);
                                                                                                // Rule at src/opts/bitops.isle line 678.
                                                                                                returns.extend(Some(v661));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                            let mut v258 = C::inst_data_value_etor_returns::default();
                                                                                            C::inst_data_value_etor(ctx, v135.1, &mut v258);
                                                                                            let mut v258 = v258.into_context_iter();
                                                                                            while let Some(v259) = v258.next(ctx) {
                                                                                                if let &InstructionData::Unary {
                                                                                                    opcode: ref v627,
                                                                                                    arg: v628,
                                                                                                } = &v259.1 {
                                                                                                    if let &Opcode::Bnot = v627 {
                                                                                                        if v628 == v655.1 {
                                                                                                            if v2.0 == v259.0 {
                                                                                                                let v738 = constructor_bnot(ctx, v2.0, v655.1);
                                                                                                                // Rule at src/opts/bitops.isle line 658.
                                                                                                                returns.extend(Some(v738));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                        if v135.0 == v655.1 {
                                                                                            if v135.1 == v655.0 {
                                                                                                let v660 = constructor_bxor(ctx, v2.0, v655.1, v655.0);
                                                                                                let v661 = constructor_bnot(ctx, v2.0, v660);
                                                                                                // Rule at src/opts/bitops.isle line 674.
                                                                                                returns.extend(Some(v661));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v658 = constructor_bxor(ctx, v2.0, v655.0, v655.1);
                                                                                                let v659 = constructor_bnot(ctx, v2.0, v658);
                                                                                                // Rule at src/opts/bitops.isle line 676.
                                                                                                returns.extend(Some(v659));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                            let mut v258 = C::inst_data_value_etor_returns::default();
                                                                                            C::inst_data_value_etor(ctx, v135.1, &mut v258);
                                                                                            let mut v258 = v258.into_context_iter();
                                                                                            while let Some(v259) = v258.next(ctx) {
                                                                                                if let &InstructionData::Unary {
                                                                                                    opcode: ref v627,
                                                                                                    arg: v628,
                                                                                                } = &v259.1 {
                                                                                                    if let &Opcode::Bnot = v627 {
                                                                                                        if v628 == v655.0 {
                                                                                                            if v2.0 == v259.0 {
                                                                                                                let v734 = constructor_bnot(ctx, v2.0, v655.0);
                                                                                                                // Rule at src/opts/bitops.isle line 656.
                                                                                                                returns.extend(Some(v734));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                        let mut v274 = C::inst_data_value_etor_returns::default();
                                                                                        C::inst_data_value_etor(ctx, v135.0, &mut v274);
                                                                                        let mut v274 = v274.into_context_iter();
                                                                                        while let Some(v275) = v274.next(ctx) {
                                                                                            if let &InstructionData::Unary {
                                                                                                opcode: ref v630,
                                                                                                arg: v631,
                                                                                            } = &v275.1 {
                                                                                                if let &Opcode::Bnot = v630 {
                                                                                                    if v2.0 == v275.0 {
                                                                                                        if v631 == v655.0 {
                                                                                                            if v135.1 == v655.1 {
                                                                                                                let v734 = constructor_bnot(ctx, v2.0, v655.0);
                                                                                                                // Rule at src/opts/bitops.isle line 652.
                                                                                                                returns.extend(Some(v734));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                        if v631 == v655.1 {
                                                                                                            if v135.1 == v655.0 {
                                                                                                                let v738 = constructor_bnot(ctx, v2.0, v655.1);
                                                                                                                // Rule at src/opts/bitops.isle line 654.
                                                                                                                returns.extend(Some(v738));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                                &Opcode::Bxor => {
                                                                                    if v2.0 == v650.0 {
                                                                                        let v135 = C::unpack_value_array_2(ctx, v134);
                                                                                        let v655 = C::unpack_value_array_2(ctx, v654);
                                                                                        if v135.0 == v655.0 {
                                                                                            if v135.1 == v655.1 {
                                                                                                let v658 = constructor_bxor(ctx, v2.0, v655.0, v655.1);
                                                                                                let v659 = constructor_bnot(ctx, v2.0, v658);
                                                                                                // Rule at src/opts/bitops.isle line 230.
                                                                                                returns.extend(Some(v659));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v660 = constructor_bxor(ctx, v2.0, v655.1, v655.0);
                                                                                                let v661 = constructor_bnot(ctx, v2.0, v660);
                                                                                                // Rule at src/opts/bitops.isle line 236.
                                                                                                returns.extend(Some(v661));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                        if v135.0 == v655.1 {
                                                                                            if v135.1 == v655.0 {
                                                                                                let v660 = constructor_bxor(ctx, v2.0, v655.1, v655.0);
                                                                                                let v661 = constructor_bnot(ctx, v2.0, v660);
                                                                                                // Rule at src/opts/bitops.isle line 232.
                                                                                                returns.extend(Some(v661));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v658 = constructor_bxor(ctx, v2.0, v655.0, v655.1);
                                                                                                let v659 = constructor_bnot(ctx, v2.0, v658);
                                                                                                // Rule at src/opts/bitops.isle line 234.
                                                                                                returns.extend(Some(v659));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                                _ => {}
                                                                            }
                                                                        }
                                                                    }
                                                                    let v135 = C::unpack_value_array_2(ctx, v134);
                                                                    if v30 == v135.0 {
                                                                        let v635 = constructor_bnot(ctx, v2.0, v30);
                                                                        let v636 = constructor_bor(ctx, v2.0, v135.1, v635);
                                                                        // Rule at src/opts/bitops.isle line 221.
                                                                        returns.extend(Some(v636));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v30 == v135.1 {
                                                                        let v350 = constructor_bor(ctx, v2.0, v135.0, v7.0);
                                                                        // Rule at src/opts/bitops.isle line 53.
                                                                        returns.extend(Some(v350));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let v135 = C::unpack_value_array_2(ctx, v134);
                                                let mut v258 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v135.1, &mut v258);
                                                let mut v258 = v258.into_context_iter();
                                                while let Some(v259) = v258.next(ctx) {
                                                    match &v259.1 {
                                                        &InstructionData::Binary {
                                                            opcode: ref v262,
                                                            args: ref v263,
                                                        } => {
                                                            match v262 {
                                                                &Opcode::Bor => {
                                                                    if v2.0 == v259.0 {
                                                                        let v264 = C::unpack_value_array_2(ctx, v263);
                                                                        if v7.0 == v264.0 {
                                                                            let v832 = constructor_band(ctx, v2.0, v135.0, v264.1);
                                                                            let v833 = constructor_bor(ctx, v2.0, v832, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 497.
                                                                            returns.extend(Some(v833));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.0 == v264.1 {
                                                                            let v840 = constructor_band(ctx, v2.0, v135.0, v264.0);
                                                                            let v841 = constructor_bor(ctx, v2.0, v840, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 501.
                                                                            returns.extend(Some(v841));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Bxor => {
                                                                    if v2.0 == v259.0 {
                                                                        let v264 = C::unpack_value_array_2(ctx, v263);
                                                                        if v7.0 == v264.0 {
                                                                            let v810 = constructor_band(ctx, v2.0, v264.1, v135.0);
                                                                            let v811 = constructor_bor(ctx, v2.0, v810, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 441.
                                                                            returns.extend(Some(v811));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.0 == v264.1 {
                                                                            let v802 = constructor_band(ctx, v2.0, v264.0, v135.0);
                                                                            let v803 = constructor_bor(ctx, v2.0, v802, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 437.
                                                                            returns.extend(Some(v803));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v627,
                                                            arg: v628,
                                                        } => {
                                                            if let &Opcode::Bnot = v627 {
                                                                if v7.0 == v628 {
                                                                    if v2.0 == v259.0 {
                                                                        let v785 = constructor_bor(ctx, v2.0, v7.0, v135.0);
                                                                        // Rule at src/opts/bitops.isle line 534.
                                                                        returns.extend(Some(v785));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let mut v274 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v135.0, &mut v274);
                                                let mut v274 = v274.into_context_iter();
                                                while let Some(v275) = v274.next(ctx) {
                                                    match &v275.1 {
                                                        &InstructionData::Binary {
                                                            opcode: ref v278,
                                                            args: ref v279,
                                                        } => {
                                                            match v278 {
                                                                &Opcode::Bor => {
                                                                    if v2.0 == v275.0 {
                                                                        let v280 = C::unpack_value_array_2(ctx, v279);
                                                                        if v7.0 == v280.0 {
                                                                            let v836 = constructor_band(ctx, v2.0, v135.1, v280.1);
                                                                            let v837 = constructor_bor(ctx, v2.0, v836, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 499.
                                                                            returns.extend(Some(v837));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.0 == v280.1 {
                                                                            let v844 = constructor_band(ctx, v2.0, v135.1, v280.0);
                                                                            let v845 = constructor_bor(ctx, v2.0, v844, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 503.
                                                                            returns.extend(Some(v845));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Bxor => {
                                                                    if v2.0 == v275.0 {
                                                                        let v280 = C::unpack_value_array_2(ctx, v279);
                                                                        if v7.0 == v280.0 {
                                                                            let v806 = constructor_band(ctx, v2.0, v280.1, v135.1);
                                                                            let v807 = constructor_bor(ctx, v2.0, v806, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 439.
                                                                            returns.extend(Some(v807));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.0 == v280.1 {
                                                                            let v798 = constructor_band(ctx, v2.0, v280.0, v135.1);
                                                                            let v799 = constructor_bor(ctx, v2.0, v798, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 435.
                                                                            returns.extend(Some(v799));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v630,
                                                            arg: v631,
                                                        } => {
                                                            if let &Opcode::Bnot = v630 {
                                                                if v7.0 == v631 {
                                                                    if v2.0 == v275.0 {
                                                                        let v622 = constructor_bor(ctx, v2.0, v7.0, v135.1);
                                                                        // Rule at src/opts/bitops.isle line 532.
                                                                        returns.extend(Some(v622));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                if v7.0 == v135.0 {
                                                    // Rule at src/opts/bitops.isle line 213.
                                                    returns.extend(Some(v7.0));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                            let v1090 = C::ty_vec128(ctx, v2.0);
                                            if let Some(v1091) = v1090 {
                                                if v11.0 == v1091 {
                                                    let mut v18 = C::inst_data_value_etor_returns::default();
                                                    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 v97,
                                                            args: ref v98,
                                                        } = &v19.1 {
                                                            if let &Opcode::Band = v97 {
                                                                if v11.0 == v19.0 {
                                                                    let v99 = C::unpack_value_array_2(ctx, v98);
                                                                    let mut v102 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v99.0, &mut v102);
                                                                    let mut v102 = v102.into_context_iter();
                                                                    while let Some(v103) = v102.next(ctx) {
                                                                        if let &InstructionData::Unary {
                                                                            opcode: ref v106,
                                                                            arg: v107,
                                                                        } = &v103.1 {
                                                                            if let &Opcode::Bnot = v106 {
                                                                                if v11.0 == v103.0 {
                                                                                    let v135 = C::unpack_value_array_2(ctx, v134);
                                                                                    if v107 == v135.0 {
                                                                                        let v1649 = constructor_bitselect(ctx, v1091, v107, v135.1, v99.1);
                                                                                        // Rule at src/opts/selects.isle line 73.
                                                                                        returns.extend(Some(v1649));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v107 == v135.1 {
                                                                                        let v1650 = constructor_bitselect(ctx, v1091, v107, v135.0, v99.1);
                                                                                        // Rule at src/opts/selects.isle line 74.
                                                                                        returns.extend(Some(v1650));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    let mut v109 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                                    let mut v109 = v109.into_context_iter();
                                                                    while let Some(v110) = v109.next(ctx) {
                                                                        if let &InstructionData::Unary {
                                                                            opcode: ref v113,
                                                                            arg: v114,
                                                                        } = &v110.1 {
                                                                            if let &Opcode::Bnot = v113 {
                                                                                if v11.0 == v110.0 {
                                                                                    let v135 = C::unpack_value_array_2(ctx, v134);
                                                                                    if v114 == v135.0 {
                                                                                        let v1651 = constructor_bitselect(ctx, v1091, v114, v135.1, v99.0);
                                                                                        // Rule at src/opts/selects.isle line 75.
                                                                                        returns.extend(Some(v1651));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v114 == v135.1 {
                                                                                        let v1652 = constructor_bitselect(ctx, v1091, v114, v135.0, v99.0);
                                                                                        // Rule at src/opts/selects.isle line 76.
                                                                                        returns.extend(Some(v1652));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    let v135 = C::unpack_value_array_2(ctx, v134);
                                                                    let mut v258 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v135.1, &mut v258);
                                                                    let mut v258 = v258.into_context_iter();
                                                                    while let Some(v259) = v258.next(ctx) {
                                                                        if let &InstructionData::Unary {
                                                                            opcode: ref v627,
                                                                            arg: v628,
                                                                        } = &v259.1 {
                                                                            if let &Opcode::Bnot = v627 {
                                                                                if v11.0 == v259.0 {
                                                                                    if v99.0 == v628 {
                                                                                        let v1646 = constructor_bitselect(ctx, v1091, v99.0, v99.1, v135.0);
                                                                                        // Rule at src/opts/selects.isle line 70.
                                                                                        returns.extend(Some(v1646));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v99.1 == v628 {
                                                                                        let v1648 = constructor_bitselect(ctx, v1091, v99.1, v99.0, v135.0);
                                                                                        // Rule at src/opts/selects.isle line 72.
                                                                                        returns.extend(Some(v1648));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    let mut v274 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v135.0, &mut v274);
                                                                    let mut v274 = v274.into_context_iter();
                                                                    while let Some(v275) = v274.next(ctx) {
                                                                        if let &InstructionData::Unary {
                                                                            opcode: ref v630,
                                                                            arg: v631,
                                                                        } = &v275.1 {
                                                                            if let &Opcode::Bnot = v630 {
                                                                                if v11.0 == v275.0 {
                                                                                    if v99.0 == v631 {
                                                                                        let v1645 = constructor_bitselect(ctx, v1091, v99.0, v99.1, v135.1);
                                                                                        // Rule at src/opts/selects.isle line 69.
                                                                                        returns.extend(Some(v1645));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v99.1 == v631 {
                                                                                        let v1647 = constructor_bitselect(ctx, v1091, v99.1, v99.0, v135.1);
                                                                                        // Rule at src/opts/selects.isle line 71.
                                                                                        returns.extend(Some(v1647));
                                                                                        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 v97,
                                                        args: ref v98,
                                                    } = &v19.1 {
                                                        match v97 {
                                                            &Opcode::Bor => {
                                                                if v2.0 == v19.0 {
                                                                    let v99 = C::unpack_value_array_2(ctx, v98);
                                                                    let mut v109 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                                    let mut v109 = v109.into_context_iter();
                                                                    while let Some(v110) = v109.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v127,
                                                                            imm: v128,
                                                                        } = &v110.1 {
                                                                            if let &Opcode::Iconst = v127 {
                                                                                let v135 = C::unpack_value_array_2(ctx, v134);
                                                                                let mut v258 = C::inst_data_value_etor_returns::default();
                                                                                C::inst_data_value_etor(ctx, v135.1, &mut v258);
                                                                                let mut v258 = v258.into_context_iter();
                                                                                while let Some(v259) = v258.next(ctx) {
                                                                                    if let &InstructionData::UnaryImm {
                                                                                        opcode: ref v1124,
                                                                                        imm: v1125,
                                                                                    } = &v259.1 {
                                                                                        if let &Opcode::Iconst = v1124 {
                                                                                            let v684 = constructor_bor(ctx, v2.0, v99.0, v135.0);
                                                                                            let v1133 = constructor_bor(ctx, v2.0, v99.1, v135.1);
                                                                                            let v1134 = constructor_bor(ctx, v2.0, v684, v1133);
                                                                                            // Rule at src/opts/cprop.isle line 325.
                                                                                            returns.extend(Some(v1134));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Bxor => {
                                                                if v2.0 == v19.0 {
                                                                    let v99 = C::unpack_value_array_2(ctx, v98);
                                                                    let v135 = C::unpack_value_array_2(ctx, v134);
                                                                    if v99.0 == v135.0 {
                                                                        if v99.1 == v135.1 {
                                                                            let v240 = constructor_bor(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/bitops.isle line 615.
                                                                            returns.extend(Some(v240));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            let v241 = constructor_bor(ctx, v2.0, v99.1, v99.0);
                                                                            // Rule at src/opts/bitops.isle line 621.
                                                                            returns.extend(Some(v241));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        let v694 = constructor_bor(ctx, v2.0, v135.1, v99.0);
                                                                        let v790 = constructor_bor(ctx, v2.0, v694, v99.1);
                                                                        // Rule at src/opts/bitops.isle line 416.
                                                                        returns.extend(Some(v790));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        let v688 = constructor_bor(ctx, v2.0, v99.0, v135.1);
                                                                        let v812 = constructor_bor(ctx, v2.0, v688, v99.1);
                                                                        // Rule at src/opts/bitops.isle line 445.
                                                                        returns.extend(Some(v812));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v99.0 == v135.1 {
                                                                        if v99.1 == v135.0 {
                                                                            let v241 = constructor_bor(ctx, v2.0, v99.1, v99.0);
                                                                            // Rule at src/opts/bitops.isle line 617.
                                                                            returns.extend(Some(v241));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            let v240 = constructor_bor(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/bitops.isle line 619.
                                                                            returns.extend(Some(v240));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        let v686 = constructor_bor(ctx, v2.0, v135.0, v99.0);
                                                                        let v788 = constructor_bor(ctx, v2.0, v686, v99.1);
                                                                        // Rule at src/opts/bitops.isle line 414.
                                                                        returns.extend(Some(v788));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        let v684 = constructor_bor(ctx, v2.0, v99.0, v135.0);
                                                                        let v814 = constructor_bor(ctx, v2.0, v684, v99.1);
                                                                        // Rule at src/opts/bitops.isle line 449.
                                                                        returns.extend(Some(v814));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v99.1 == v135.0 {
                                                                        let v698 = constructor_bor(ctx, v2.0, v135.1, v99.1);
                                                                        let v794 = constructor_bor(ctx, v2.0, v698, v99.0);
                                                                        // Rule at src/opts/bitops.isle line 420.
                                                                        returns.extend(Some(v794));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        let v696 = constructor_bor(ctx, v2.0, v99.1, v135.1);
                                                                        let v813 = constructor_bor(ctx, v2.0, v696, v99.0);
                                                                        // Rule at src/opts/bitops.isle line 447.
                                                                        returns.extend(Some(v813));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v99.1 == v135.1 {
                                                                        let v690 = constructor_bor(ctx, v2.0, v135.0, v99.1);
                                                                        let v792 = constructor_bor(ctx, v2.0, v690, v99.0);
                                                                        // Rule at src/opts/bitops.isle line 418.
                                                                        returns.extend(Some(v792));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        let v692 = constructor_bor(ctx, v2.0, v99.1, v135.0);
                                                                        let v815 = constructor_bor(ctx, v2.0, v692, v99.0);
                                                                        // Rule at src/opts/bitops.isle line 451.
                                                                        returns.extend(Some(v815));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                    }
                                                }
                                                let v135 = C::unpack_value_array_2(ctx, v134);
                                                if v7.0 == v135.0 {
                                                    let v622 = constructor_bor(ctx, v2.0, v7.0, v135.1);
                                                    // Rule at src/opts/bitops.isle line 189.
                                                    returns.extend(Some(v622));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.0 == v135.1 {
                                                    let v350 = constructor_bor(ctx, v2.0, v135.0, v7.0);
                                                    // Rule at src/opts/bitops.isle line 190.
                                                    returns.extend(Some(v350));
                                                    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 v97,
                                                                    args: ref v98,
                                                                } = &v19.1 {
                                                                    if let &Opcode::Bor = v97 {
                                                                        let v99 = C::unpack_value_array_2(ctx, v98);
                                                                        let mut v102 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v99.0, &mut v102);
                                                                        let mut v102 = v102.into_context_iter();
                                                                        while let Some(v103) = v102.next(ctx) {
                                                                            if v103.0 == I32 {
                                                                                if let &InstructionData::Binary {
                                                                                    opcode: ref v284,
                                                                                    args: ref v285,
                                                                                } = &v103.1 {
                                                                                    if let &Opcode::Ishl = v284 {
                                                                                        let mut v109 = C::inst_data_value_etor_returns::default();
                                                                                        C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                                                        let mut v109 = v109.into_context_iter();
                                                                                        while let Some(v110) = v109.next(ctx) {
                                                                                            if v110.0 == I32 {
                                                                                                if let &InstructionData::Binary {
                                                                                                    opcode: ref v268,
                                                                                                    args: ref v269,
                                                                                                } = &v110.1 {
                                                                                                    if let &Opcode::Ishl = v268 {
                                                                                                        let v135 = C::unpack_value_array_2(ctx, v134);
                                                                                                        let mut v258 = C::inst_data_value_etor_returns::default();
                                                                                                        C::inst_data_value_etor(ctx, v135.1, &mut v258);
                                                                                                        let mut v258 = v258.into_context_iter();
                                                                                                        while let Some(v259) = v258.next(ctx) {
                                                                                                            if v259.0 == I32 {
                                                                                                                if let &InstructionData::Binary {
                                                                                                                    opcode: ref v262,
                                                                                                                    args: ref v263,
                                                                                                                } = &v259.1 {
                                                                                                                    if let &Opcode::Ushr = v262 {
                                                                                                                        let v264 = C::unpack_value_array_2(ctx, v263);
                                                                                                                        let v286 = C::unpack_value_array_2(ctx, v285);
                                                                                                                        if v264.0 == v286.0 {
                                                                                                                            let mut v274 = C::inst_data_value_etor_returns::default();
                                                                                                                            C::inst_data_value_etor(ctx, v135.0, &mut v274);
                                                                                                                            let mut v274 = v274.into_context_iter();
                                                                                                                            while let Some(v275) = v274.next(ctx) {
                                                                                                                                if v275.0 == I32 {
                                                                                                                                    if let &InstructionData::Binary {
                                                                                                                                        opcode: ref v278,
                                                                                                                                        args: ref v279,
                                                                                                                                    } = &v275.1 {
                                                                                                                                        if let &Opcode::Band = v278 {
                                                                                                                                            let mut v384 = C::inst_data_value_etor_returns::default();
                                                                                                                                            C::inst_data_value_etor(ctx, v286.1, &mut v384);
                                                                                                                                            let mut v384 = v384.into_context_iter();
                                                                                                                                            while let Some(v385) = v384.next(ctx) {
                                                                                                                                                if v385.0 == I32 {
                                                                                                                                                    if let &InstructionData::UnaryImm {
                                                                                                                                                        opcode: ref v388,
                                                                                                                                                        imm: v389,
                                                                                                                                                    } = &v385.1 {
                                                                                                                                                        if let &Opcode::Iconst = v388 {
                                                                                                                                                            let v390 = C::u64_from_imm64(ctx, v389);
                                                                                                                                                            if v390 == 0x18_u64 {
                                                                                                                                                                let v270 = C::unpack_value_array_2(ctx, v269);
                                                                                                                                                                let mut v391 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                C::inst_data_value_etor(ctx, v270.0, &mut v391);
                                                                                                                                                                let mut v391 = v391.into_context_iter();
                                                                                                                                                                while let Some(v392) = v391.next(ctx) {
                                                                                                                                                                    if v392.0 == I32 {
                                                                                                                                                                        if let &InstructionData::Binary {
                                                                                                                                                                            opcode: ref v395,
                                                                                                                                                                            args: ref v396,
                                                                                                                                                                        } = &v392.1 {
                                                                                                                                                                            if let &Opcode::Band = v395 {
                                                                                                                                                                                let v397 = C::unpack_value_array_2(ctx, v396);
                                                                                                                                                                                if v264.0 == v397.0 {
                                                                                                                                                                                    let mut v400 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                    C::inst_data_value_etor(ctx, v397.1, &mut v400);
                                                                                                                                                                                    let mut v400 = v400.into_context_iter();
                                                                                                                                                                                    while let Some(v401) = v400.next(ctx) {
                                                                                                                                                                                        if v401.0 == I32 {
                                                                                                                                                                                            if let &InstructionData::UnaryImm {
                                                                                                                                                                                                opcode: ref v404,
                                                                                                                                                                                                imm: v405,
                                                                                                                                                                                            } = &v401.1 {
                                                                                                                                                                                                if let &Opcode::Iconst = v404 {
                                                                                                                                                                                                    let v406 = C::u64_from_imm64(ctx, v405);
                                                                                                                                                                                                    if v406 == 0xff00_u64 {
                                                                                                                                                                                                        let mut v407 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                        C::inst_data_value_etor(ctx, v270.1, &mut v407);
                                                                                                                                                                                                        let mut v407 = v407.into_context_iter();
                                                                                                                                                                                                        while let Some(v408) = v407.next(ctx) {
                                                                                                                                                                                                            if v408.0 == I32 {
                                                                                                                                                                                                                if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                    opcode: ref v411,
                                                                                                                                                                                                                    imm: v412,
                                                                                                                                                                                                                } = &v408.1 {
                                                                                                                                                                                                                    if let &Opcode::Iconst = v411 {
                                                                                                                                                                                                                        let v413 = C::u64_from_imm64(ctx, v412);
                                                                                                                                                                                                                        if v413 == 0x8_u64 {
                                                                                                                                                                                                                            let v280 = C::unpack_value_array_2(ctx, v279);
                                                                                                                                                                                                                            let mut v414 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                            C::inst_data_value_etor(ctx, v280.0, &mut v414);
                                                                                                                                                                                                                            let mut v414 = v414.into_context_iter();
                                                                                                                                                                                                                            while let Some(v415) = v414.next(ctx) {
                                                                                                                                                                                                                                if v415.0 == I32 {
                                                                                                                                                                                                                                    if let &InstructionData::Binary {
                                                                                                                                                                                                                                        opcode: ref v418,
                                                                                                                                                                                                                                        args: ref v419,
                                                                                                                                                                                                                                    } = &v415.1 {
                                                                                                                                                                                                                                        if let &Opcode::Ushr = v418 {
                                                                                                                                                                                                                                            let v420 = C::unpack_value_array_2(ctx, v419);
                                                                                                                                                                                                                                            if v264.0 == v420.0 {
                                                                                                                                                                                                                                                let mut v423 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                C::inst_data_value_etor(ctx, v420.1, &mut v423);
                                                                                                                                                                                                                                                let mut v423 = v423.into_context_iter();
                                                                                                                                                                                                                                                while let Some(v424) = v423.next(ctx) {
                                                                                                                                                                                                                                                    if v424.0 == I32 {
                                                                                                                                                                                                                                                        if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                            opcode: ref v427,
                                                                                                                                                                                                                                                            imm: v428,
                                                                                                                                                                                                                                                        } = &v424.1 {
                                                                                                                                                                                                                                                            if let &Opcode::Iconst = v427 {
                                                                                                                                                                                                                                                                let v429 = C::u64_from_imm64(ctx, v428);
                                                                                                                                                                                                                                                                if v429 == 0x8_u64 {
                                                                                                                                                                                                                                                                    let mut v430 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                    C::inst_data_value_etor(ctx, v280.1, &mut v430);
                                                                                                                                                                                                                                                                    let mut v430 = v430.into_context_iter();
                                                                                                                                                                                                                                                                    while let Some(v431) = v430.next(ctx) {
                                                                                                                                                                                                                                                                        if v431.0 == I32 {
                                                                                                                                                                                                                                                                            if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                opcode: ref v434,
                                                                                                                                                                                                                                                                                imm: v435,
                                                                                                                                                                                                                                                                            } = &v431.1 {
                                                                                                                                                                                                                                                                                if let &Opcode::Iconst = v434 {
                                                                                                                                                                                                                                                                                    let v436 = C::u64_from_imm64(ctx, v435);
                                                                                                                                                                                                                                                                                    if v436 == 0xff00_u64 {
                                                                                                                                                                                                                                                                                        let mut v437 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                        C::inst_data_value_etor(ctx, v264.1, &mut v437);
                                                                                                                                                                                                                                                                                        let mut v437 = v437.into_context_iter();
                                                                                                                                                                                                                                                                                        while let Some(v438) = v437.next(ctx) {
                                                                                                                                                                                                                                                                                            if v438.0 == I32 {
                                                                                                                                                                                                                                                                                                if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                    opcode: ref v441,
                                                                                                                                                                                                                                                                                                    imm: v442,
                                                                                                                                                                                                                                                                                                } = &v438.1 {
                                                                                                                                                                                                                                                                                                    if let &Opcode::Iconst = v441 {
                                                                                                                                                                                                                                                                                                        let v443 = C::u64_from_imm64(ctx, v442);
                                                                                                                                                                                                                                                                                                        if v443 == 0x18_u64 {
                                                                                                                                                                                                                                                                                                            let v444 = constructor_bswap(ctx, v2.0, v286.0);
                                                                                                                                                                                                                                                                                                            // Rule at src/opts/bitops.isle line 142.
                                                                                                                                                                                                                                                                                                            returns.extend(Some(v444));
                                                                                                                                                                                                                                                                                                            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 v97,
                                                                    args: ref v98,
                                                                } = &v19.1 {
                                                                    if let &Opcode::Bor = v97 {
                                                                        let v99 = C::unpack_value_array_2(ctx, v98);
                                                                        let mut v102 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v99.0, &mut v102);
                                                                        let mut v102 = v102.into_context_iter();
                                                                        while let Some(v103) = v102.next(ctx) {
                                                                            if v103.0 == I64 {
                                                                                if let &InstructionData::Binary {
                                                                                    opcode: ref v284,
                                                                                    args: ref v285,
                                                                                } = &v103.1 {
                                                                                    if let &Opcode::Bor = v284 {
                                                                                        let mut v109 = C::inst_data_value_etor_returns::default();
                                                                                        C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                                                        let mut v109 = v109.into_context_iter();
                                                                                        while let Some(v110) = v109.next(ctx) {
                                                                                            if v110.0 == I64 {
                                                                                                if let &InstructionData::Binary {
                                                                                                    opcode: ref v268,
                                                                                                    args: ref v269,
                                                                                                } = &v110.1 {
                                                                                                    if let &Opcode::Bor = v268 {
                                                                                                        let v135 = C::unpack_value_array_2(ctx, v134);
                                                                                                        let mut v258 = C::inst_data_value_etor_returns::default();
                                                                                                        C::inst_data_value_etor(ctx, v135.1, &mut v258);
                                                                                                        let mut v258 = v258.into_context_iter();
                                                                                                        while let Some(v259) = v258.next(ctx) {
                                                                                                            if v259.0 == I64 {
                                                                                                                if let &InstructionData::Binary {
                                                                                                                    opcode: ref v262,
                                                                                                                    args: ref v263,
                                                                                                                } = &v259.1 {
                                                                                                                    if let &Opcode::Bor = v262 {
                                                                                                                        let mut v274 = C::inst_data_value_etor_returns::default();
                                                                                                                        C::inst_data_value_etor(ctx, v135.0, &mut v274);
                                                                                                                        let mut v274 = v274.into_context_iter();
                                                                                                                        while let Some(v275) = v274.next(ctx) {
                                                                                                                            if v275.0 == I64 {
                                                                                                                                if let &InstructionData::Binary {
                                                                                                                                    opcode: ref v278,
                                                                                                                                    args: ref v279,
                                                                                                                                } = &v275.1 {
                                                                                                                                    if let &Opcode::Bor = v278 {
                                                                                                                                        let v286 = C::unpack_value_array_2(ctx, v285);
                                                                                                                                        let mut v384 = C::inst_data_value_etor_returns::default();
                                                                                                                                        C::inst_data_value_etor(ctx, v286.1, &mut v384);
                                                                                                                                        let mut v384 = v384.into_context_iter();
                                                                                                                                        while let Some(v385) = v384.next(ctx) {
                                                                                                                                            if v385.0 == I64 {
                                                                                                                                                if let &InstructionData::Binary {
                                                                                                                                                    opcode: ref v461,
                                                                                                                                                    args: ref v462,
                                                                                                                                                } = &v385.1 {
                                                                                                                                                    if let &Opcode::Ishl = v461 {
                                                                                                                                                        let v270 = C::unpack_value_array_2(ctx, v269);
                                                                                                                                                        let mut v391 = C::inst_data_value_etor_returns::default();
                                                                                                                                                        C::inst_data_value_etor(ctx, v270.0, &mut v391);
                                                                                                                                                        let mut v391 = v391.into_context_iter();
                                                                                                                                                        while let Some(v392) = v391.next(ctx) {
                                                                                                                                                            if v392.0 == I64 {
                                                                                                                                                                if let &InstructionData::Binary {
                                                                                                                                                                    opcode: ref v395,
                                                                                                                                                                    args: ref v396,
                                                                                                                                                                } = &v392.1 {
                                                                                                                                                                    if let &Opcode::Ishl = v395 {
                                                                                                                                                                        let v397 = C::unpack_value_array_2(ctx, v396);
                                                                                                                                                                        let mut v400 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                        C::inst_data_value_etor(ctx, v397.1, &mut v400);
                                                                                                                                                                        let mut v400 = v400.into_context_iter();
                                                                                                                                                                        while let Some(v401) = v400.next(ctx) {
                                                                                                                                                                            if v401.0 == I64 {
                                                                                                                                                                                if let &InstructionData::UnaryImm {
                                                                                                                                                                                    opcode: ref v404,
                                                                                                                                                                                    imm: v405,
                                                                                                                                                                                } = &v401.1 {
                                                                                                                                                                                    if let &Opcode::Iconst = v404 {
                                                                                                                                                                                        let v406 = C::u64_from_imm64(ctx, v405);
                                                                                                                                                                                        if v406 == 0x18_u64 {
                                                                                                                                                                                            let mut v407 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                            C::inst_data_value_etor(ctx, v270.1, &mut v407);
                                                                                                                                                                                            let mut v407 = v407.into_context_iter();
                                                                                                                                                                                            while let Some(v408) = v407.next(ctx) {
                                                                                                                                                                                                if v408.0 == I64 {
                                                                                                                                                                                                    if let &InstructionData::Binary {
                                                                                                                                                                                                        opcode: ref v505,
                                                                                                                                                                                                        args: ref v506,
                                                                                                                                                                                                    } = &v408.1 {
                                                                                                                                                                                                        if let &Opcode::Ishl = v505 {
                                                                                                                                                                                                            let v280 = C::unpack_value_array_2(ctx, v279);
                                                                                                                                                                                                            let mut v414 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                            C::inst_data_value_etor(ctx, v280.0, &mut v414);
                                                                                                                                                                                                            let mut v414 = v414.into_context_iter();
                                                                                                                                                                                                            while let Some(v415) = v414.next(ctx) {
                                                                                                                                                                                                                if v415.0 == I64 {
                                                                                                                                                                                                                    if let &InstructionData::Binary {
                                                                                                                                                                                                                        opcode: ref v418,
                                                                                                                                                                                                                        args: ref v419,
                                                                                                                                                                                                                    } = &v415.1 {
                                                                                                                                                                                                                        if let &Opcode::Band = v418 {
                                                                                                                                                                                                                            let v420 = C::unpack_value_array_2(ctx, v419);
                                                                                                                                                                                                                            let mut v423 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                            C::inst_data_value_etor(ctx, v420.1, &mut v423);
                                                                                                                                                                                                                            let mut v423 = v423.into_context_iter();
                                                                                                                                                                                                                            while let Some(v424) = v423.next(ctx) {
                                                                                                                                                                                                                                if v424.0 == I64 {
                                                                                                                                                                                                                                    if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                        opcode: ref v427,
                                                                                                                                                                                                                                        imm: v428,
                                                                                                                                                                                                                                    } = &v424.1 {
                                                                                                                                                                                                                                        if let &Opcode::Iconst = v427 {
                                                                                                                                                                                                                                            let v429 = C::u64_from_imm64(ctx, v428);
                                                                                                                                                                                                                                            if v429 == 0xff000000_u64 {
                                                                                                                                                                                                                                                let mut v430 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                C::inst_data_value_etor(ctx, v280.1, &mut v430);
                                                                                                                                                                                                                                                let mut v430 = v430.into_context_iter();
                                                                                                                                                                                                                                                while let Some(v431) = v430.next(ctx) {
                                                                                                                                                                                                                                                    if v431.0 == I64 {
                                                                                                                                                                                                                                                        if let &InstructionData::Binary {
                                                                                                                                                                                                                                                            opcode: ref v549,
                                                                                                                                                                                                                                                            args: ref v550,
                                                                                                                                                                                                                                                        } = &v431.1 {
                                                                                                                                                                                                                                                            if let &Opcode::Band = v549 {
                                                                                                                                                                                                                                                                let v264 = C::unpack_value_array_2(ctx, v263);
                                                                                                                                                                                                                                                                let mut v437 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                C::inst_data_value_etor(ctx, v264.1, &mut v437);
                                                                                                                                                                                                                                                                let mut v437 = v437.into_context_iter();
                                                                                                                                                                                                                                                                while let Some(v438) = v437.next(ctx) {
                                                                                                                                                                                                                                                                    if v438.0 == I64 {
                                                                                                                                                                                                                                                                        if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                            opcode: ref v609,
                                                                                                                                                                                                                                                                            args: ref v610,
                                                                                                                                                                                                                                                                        } = &v438.1 {
                                                                                                                                                                                                                                                                            if let &Opcode::Ushr = v609 {
                                                                                                                                                                                                                                                                                let mut v445 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                C::inst_data_value_etor(ctx, v286.0, &mut v445);
                                                                                                                                                                                                                                                                                let mut v445 = v445.into_context_iter();
                                                                                                                                                                                                                                                                                while let Some(v446) = v445.next(ctx) {
                                                                                                                                                                                                                                                                                    if v446.0 == I64 {
                                                                                                                                                                                                                                                                                        if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                                            opcode: ref v449,
                                                                                                                                                                                                                                                                                            args: ref v450,
                                                                                                                                                                                                                                                                                        } = &v446.1 {
                                                                                                                                                                                                                                                                                            if let &Opcode::Ishl = v449 {
                                                                                                                                                                                                                                                                                                let v451 = C::unpack_value_array_2(ctx, v450);
                                                                                                                                                                                                                                                                                                let v611 = C::unpack_value_array_2(ctx, v610);
                                                                                                                                                                                                                                                                                                if v451.0 == v611.0 {
                                                                                                                                                                                                                                                                                                    let mut v454 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                    C::inst_data_value_etor(ctx, v451.1, &mut v454);
                                                                                                                                                                                                                                                                                                    let mut v454 = v454.into_context_iter();
                                                                                                                                                                                                                                                                                                    while let Some(v455) = v454.next(ctx) {
                                                                                                                                                                                                                                                                                                        if v455.0 == I64 {
                                                                                                                                                                                                                                                                                                            if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                opcode: ref v458,
                                                                                                                                                                                                                                                                                                                imm: v459,
                                                                                                                                                                                                                                                                                                            } = &v455.1 {
                                                                                                                                                                                                                                                                                                                if let &Opcode::Iconst = v458 {
                                                                                                                                                                                                                                                                                                                    let v460 = C::u64_from_imm64(ctx, v459);
                                                                                                                                                                                                                                                                                                                    if v460 == 0x38_u64 {
                                                                                                                                                                                                                                                                                                                        let v463 = C::unpack_value_array_2(ctx, v462);
                                                                                                                                                                                                                                                                                                                        let mut v466 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                        C::inst_data_value_etor(ctx, v463.0, &mut v466);
                                                                                                                                                                                                                                                                                                                        let mut v466 = v466.into_context_iter();
                                                                                                                                                                                                                                                                                                                        while let Some(v467) = v466.next(ctx) {
                                                                                                                                                                                                                                                                                                                            if v467.0 == I64 {
                                                                                                                                                                                                                                                                                                                                if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                                                                                    opcode: ref v470,
                                                                                                                                                                                                                                                                                                                                    args: ref v471,
                                                                                                                                                                                                                                                                                                                                } = &v467.1 {
                                                                                                                                                                                                                                                                                                                                    if let &Opcode::Band = v470 {
                                                                                                                                                                                                                                                                                                                                        let v472 = C::unpack_value_array_2(ctx, v471);
                                                                                                                                                                                                                                                                                                                                        if v451.0 == v472.0 {
                                                                                                                                                                                                                                                                                                                                            let mut v475 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                            C::inst_data_value_etor(ctx, v472.1, &mut v475);
                                                                                                                                                                                                                                                                                                                                            let mut v475 = v475.into_context_iter();
                                                                                                                                                                                                                                                                                                                                            while let Some(v476) = v475.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                if v476.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                    if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                        opcode: ref v479,
                                                                                                                                                                                                                                                                                                                                                        imm: v480,
                                                                                                                                                                                                                                                                                                                                                    } = &v476.1 {
                                                                                                                                                                                                                                                                                                                                                        if let &Opcode::Iconst = v479 {
                                                                                                                                                                                                                                                                                                                                                            let v481 = C::u64_from_imm64(ctx, v480);
                                                                                                                                                                                                                                                                                                                                                            if v481 == 0xff00_u64 {
                                                                                                                                                                                                                                                                                                                                                                let mut v482 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                C::inst_data_value_etor(ctx, v463.1, &mut v482);
                                                                                                                                                                                                                                                                                                                                                                let mut v482 = v482.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                while let Some(v483) = v482.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                    if v483.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                        if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                            opcode: ref v486,
                                                                                                                                                                                                                                                                                                                                                                            imm: v487,
                                                                                                                                                                                                                                                                                                                                                                        } = &v483.1 {
                                                                                                                                                                                                                                                                                                                                                                            if let &Opcode::Iconst = v486 {
                                                                                                                                                                                                                                                                                                                                                                                let v488 = C::u64_from_imm64(ctx, v487);
                                                                                                                                                                                                                                                                                                                                                                                if v488 == 0x28_u64 {
                                                                                                                                                                                                                                                                                                                                                                                    let mut v489 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                    C::inst_data_value_etor(ctx, v397.0, &mut v489);
                                                                                                                                                                                                                                                                                                                                                                                    let mut v489 = v489.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                    while let Some(v490) = v489.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                        if v490.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                            if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                                                                                                                                                opcode: ref v493,
                                                                                                                                                                                                                                                                                                                                                                                                args: ref v494,
                                                                                                                                                                                                                                                                                                                                                                                            } = &v490.1 {
                                                                                                                                                                                                                                                                                                                                                                                                if let &Opcode::Band = v493 {
                                                                                                                                                                                                                                                                                                                                                                                                    let v495 = C::unpack_value_array_2(ctx, v494);
                                                                                                                                                                                                                                                                                                                                                                                                    if v451.0 == v495.0 {
                                                                                                                                                                                                                                                                                                                                                                                                        let mut v498 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                        C::inst_data_value_etor(ctx, v495.1, &mut v498);
                                                                                                                                                                                                                                                                                                                                                                                                        let mut v498 = v498.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                        while let Some(v499) = v498.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                            if v499.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                                                                    opcode: ref v502,
                                                                                                                                                                                                                                                                                                                                                                                                                    imm: v503,
                                                                                                                                                                                                                                                                                                                                                                                                                } = &v499.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                    if let &Opcode::Iconst = v502 {
                                                                                                                                                                                                                                                                                                                                                                                                                        let v504 = C::u64_from_imm64(ctx, v503);
                                                                                                                                                                                                                                                                                                                                                                                                                        if v504 == 0xff0000_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                            let v507 = C::unpack_value_array_2(ctx, v506);
                                                                                                                                                                                                                                                                                                                                                                                                                            let mut v510 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                            C::inst_data_value_etor(ctx, v507.0, &mut v510);
                                                                                                                                                                                                                                                                                                                                                                                                                            let mut v510 = v510.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                            while let Some(v511) = v510.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                if v511.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                    if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                                                                                                                                                                                        opcode: ref v514,
                                                                                                                                                                                                                                                                                                                                                                                                                                        args: ref v515,
                                                                                                                                                                                                                                                                                                                                                                                                                                    } = &v511.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                        if let &Opcode::Band = v514 {
                                                                                                                                                                                                                                                                                                                                                                                                                                            let v516 = C::unpack_value_array_2(ctx, v515);
                                                                                                                                                                                                                                                                                                                                                                                                                                            if v451.0 == v516.0 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                let mut v519 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                C::inst_data_value_etor(ctx, v516.1, &mut v519);
                                                                                                                                                                                                                                                                                                                                                                                                                                                let mut v519 = v519.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                while let Some(v520) = v519.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                    if v520.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                        if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                                                                                                            opcode: ref v523,
                                                                                                                                                                                                                                                                                                                                                                                                                                                            imm: v524,
                                                                                                                                                                                                                                                                                                                                                                                                                                                        } = &v520.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                            if let &Opcode::Iconst = v523 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                let v525 = C::u64_from_imm64(ctx, v524);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                if v525 == 0xff000000_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mut v526 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    C::inst_data_value_etor(ctx, v507.1, &mut v526);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mut v526 = v526.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    while let Some(v527) = v526.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if v527.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                opcode: ref v530,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                imm: v531,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } = &v527.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if let &Opcode::Iconst = v530 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let v532 = C::u64_from_imm64(ctx, v531);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if v532 == 0x8_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mut v533 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        C::inst_data_value_etor(ctx, v420.0, &mut v533);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mut v533 = v533.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        while let Some(v534) = v533.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if v534.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opcode: ref v537,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    args: ref v538,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } = &v534.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if let &Opcode::Ushr = v537 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let v539 = C::unpack_value_array_2(ctx, v538);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if v451.0 == v539.0 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mut v542 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            C::inst_data_value_etor(ctx, v539.1, &mut v542);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mut v542 = v542.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            while let Some(v543) = v542.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if v543.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opcode: ref v546,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        imm: v547,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } = &v543.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if let &Opcode::Iconst = v546 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let v548 = C::u64_from_imm64(ctx, v547);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if v548 == 0x8_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let v551 = C::unpack_value_array_2(ctx, v550);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mut v554 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                C::inst_data_value_etor(ctx, v551.0, &mut v554);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mut v554 = v554.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                while let Some(v555) = v554.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if v555.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            opcode: ref v558,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            args: ref v559,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } = &v555.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if let &Opcode::Ushr = v558 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let v560 = C::unpack_value_array_2(ctx, v559);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if v451.0 == v560.0 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mut v563 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    C::inst_data_value_etor(ctx, v560.1, &mut v563);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mut v563 = v563.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    while let Some(v564) = v563.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if v564.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                opcode: ref v567,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                imm: v568,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } = &v564.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if let &Opcode::Iconst = v567 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let v569 = C::u64_from_imm64(ctx, v568);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if v569 == 0x18_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mut v570 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        C::inst_data_value_etor(ctx, v551.1, &mut v570);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mut v570 = v570.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        while let Some(v571) = v570.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if v571.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opcode: ref v574,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    imm: v575,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } = &v571.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if let &Opcode::Iconst = v574 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let v576 = C::u64_from_imm64(ctx, v575);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if v576 == 0xff0000_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mut v577 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            C::inst_data_value_etor(ctx, v264.0, &mut v577);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mut v577 = v577.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            while let Some(v578) = v577.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if v578.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opcode: ref v581,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        args: ref v582,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } = &v578.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if let &Opcode::Band = v581 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let v583 = C::unpack_value_array_2(ctx, v582);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mut v586 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            C::inst_data_value_etor(ctx, v583.0, &mut v586);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mut v586 = v586.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            while let Some(v587) = v586.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if v587.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opcode: ref v590,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        args: ref v591,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } = &v587.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if let &Opcode::Ushr = v590 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let v592 = C::unpack_value_array_2(ctx, v591);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if v451.0 == v592.0 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mut v595 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                C::inst_data_value_etor(ctx, v592.1, &mut v595);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mut v595 = v595.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                while let Some(v596) = v595.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if v596.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            opcode: ref v599,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            imm: v600,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } = &v596.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if let &Opcode::Iconst = v599 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let v601 = C::u64_from_imm64(ctx, v600);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if v601 == 0x28_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mut v602 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    C::inst_data_value_etor(ctx, v583.1, &mut v602);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mut v602 = v602.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    while let Some(v603) = v602.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if v603.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                opcode: ref v606,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                imm: v607,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } = &v603.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if let &Opcode::Iconst = v606 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let v608 = C::u64_from_imm64(ctx, v607);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if v608 == 0xff00_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mut v614 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        C::inst_data_value_etor(ctx, v611.1, &mut v614);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mut v614 = v614.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        while let Some(v615) = v614.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if v615.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opcode: ref v618,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    imm: v619,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } = &v615.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if let &Opcode::Iconst = v618 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let v620 = C::u64_from_imm64(ctx, v619);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if v620 == 0x38_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let v621 = constructor_bswap(ctx, v2.0, v451.0);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            // Rule at src/opts/bitops.isle line 155.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            returns.extend(Some(v621));
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            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 v97,
                                                            args: ref v98,
                                                        } => {
                                                            match v97 {
                                                                &Opcode::Band => {
                                                                    if v2.0 == v19.0 {
                                                                        let v99 = C::unpack_value_array_2(ctx, v98);
                                                                        let mut v102 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v99.0, &mut v102);
                                                                        let mut v102 = v102.into_context_iter();
                                                                        while let Some(v103) = v102.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v106,
                                                                                arg: v107,
                                                                            } = &v103.1 {
                                                                                if let &Opcode::Bnot = v106 {
                                                                                    if v2.0 == v103.0 {
                                                                                        let v135 = C::unpack_value_array_2(ctx, v134);
                                                                                        if v99.1 == v135.0 {
                                                                                            if v107 == v135.1 {
                                                                                                let v870 = constructor_bxor(ctx, v2.0, v99.1, v107);
                                                                                                // Rule at src/opts/bitops.isle line 562.
                                                                                                returns.extend(Some(v870));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                        if v107 == v135.0 {
                                                                                            if v99.1 == v135.1 {
                                                                                                let v870 = constructor_bxor(ctx, v2.0, v99.1, v107);
                                                                                                // Rule at src/opts/bitops.isle line 564.
                                                                                                returns.extend(Some(v870));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let mut v109 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                                        let mut v109 = v109.into_context_iter();
                                                                        while let Some(v110) = v109.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v113,
                                                                                arg: v114,
                                                                            } = &v110.1 {
                                                                                if let &Opcode::Bnot = v113 {
                                                                                    if v2.0 == v110.0 {
                                                                                        let v135 = C::unpack_value_array_2(ctx, v134);
                                                                                        if v99.0 == v135.0 {
                                                                                            if v114 == v135.1 {
                                                                                                let v868 = constructor_bxor(ctx, v2.0, v99.0, v114);
                                                                                                // Rule at src/opts/bitops.isle line 558.
                                                                                                returns.extend(Some(v868));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                        if v114 == v135.0 {
                                                                                            if v99.0 == v135.1 {
                                                                                                let v868 = constructor_bxor(ctx, v2.0, v99.0, v114);
                                                                                                // Rule at src/opts/bitops.isle line 560.
                                                                                                returns.extend(Some(v868));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Bor => {
                                                                    if v2.0 == v19.0 {
                                                                        let v99 = C::unpack_value_array_2(ctx, v98);
                                                                        let v135 = C::unpack_value_array_2(ctx, v134);
                                                                        if v99.0 == v135.0 {
                                                                            if v99.1 == v135.1 {
                                                                                let v240 = constructor_bor(ctx, v2.0, v99.0, v99.1);
                                                                                // Rule at src/opts/bitops.isle line 614.
                                                                                returns.extend(Some(v240));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                let v241 = constructor_bor(ctx, v2.0, v99.1, v99.0);
                                                                                // Rule at src/opts/bitops.isle line 620.
                                                                                returns.extend(Some(v241));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                            let v241 = constructor_bor(ctx, v2.0, v99.1, v99.0);
                                                                            let v791 = constructor_bor(ctx, v2.0, v241, v135.1);
                                                                            // Rule at src/opts/bitops.isle line 417.
                                                                            returns.extend(Some(v791));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            let v240 = constructor_bor(ctx, v2.0, v99.0, v99.1);
                                                                            let v789 = constructor_bor(ctx, v2.0, v240, v135.1);
                                                                            // Rule at src/opts/bitops.isle line 444.
                                                                            returns.extend(Some(v789));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v99.0 == v135.1 {
                                                                            if v99.1 == v135.0 {
                                                                                let v240 = constructor_bor(ctx, v2.0, v99.0, v99.1);
                                                                                // Rule at src/opts/bitops.isle line 616.
                                                                                returns.extend(Some(v240));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                let v241 = constructor_bor(ctx, v2.0, v99.1, v99.0);
                                                                                // Rule at src/opts/bitops.isle line 618.
                                                                                returns.extend(Some(v241));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                            let v241 = constructor_bor(ctx, v2.0, v99.1, v99.0);
                                                                            let v795 = constructor_bor(ctx, v2.0, v241, v135.0);
                                                                            // Rule at src/opts/bitops.isle line 421.
                                                                            returns.extend(Some(v795));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            let v240 = constructor_bor(ctx, v2.0, v99.0, v99.1);
                                                                            let v793 = constructor_bor(ctx, v2.0, v240, v135.0);
                                                                            // Rule at src/opts/bitops.isle line 446.
                                                                            returns.extend(Some(v793));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v99.1 == v135.0 {
                                                                            let v240 = constructor_bor(ctx, v2.0, v99.0, v99.1);
                                                                            let v789 = constructor_bor(ctx, v2.0, v240, v135.1);
                                                                            // Rule at src/opts/bitops.isle line 415.
                                                                            returns.extend(Some(v789));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            let v241 = constructor_bor(ctx, v2.0, v99.1, v99.0);
                                                                            let v791 = constructor_bor(ctx, v2.0, v241, v135.1);
                                                                            // Rule at src/opts/bitops.isle line 448.
                                                                            returns.extend(Some(v791));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v99.1 == v135.1 {
                                                                            let v240 = constructor_bor(ctx, v2.0, v99.0, v99.1);
                                                                            let v793 = constructor_bor(ctx, v2.0, v240, v135.0);
                                                                            // Rule at src/opts/bitops.isle line 419.
                                                                            returns.extend(Some(v793));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            let v241 = constructor_bor(ctx, v2.0, v99.1, v99.0);
                                                                            let v795 = constructor_bor(ctx, v2.0, v241, v135.0);
                                                                            // Rule at src/opts/bitops.isle line 450.
                                                                            returns.extend(Some(v795));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Bxor => {
                                                                    if v2.0 == v19.0 {
                                                                        let v99 = C::unpack_value_array_2(ctx, v98);
                                                                        let mut v102 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v99.0, &mut v102);
                                                                        let mut v102 = v102.into_context_iter();
                                                                        while let Some(v103) = v102.next(ctx) {
                                                                            if let &InstructionData::Binary {
                                                                                opcode: ref v284,
                                                                                args: ref v285,
                                                                            } = &v103.1 {
                                                                                if let &Opcode::Bxor = v284 {
                                                                                    if v2.0 == v103.0 {
                                                                                        let v135 = C::unpack_value_array_2(ctx, v134);
                                                                                        let v286 = C::unpack_value_array_2(ctx, v285);
                                                                                        if v135.0 == v286.0 {
                                                                                            if v135.1 == v286.1 {
                                                                                                let v774 = constructor_bxor(ctx, v2.0, v286.0, v286.1);
                                                                                                let v775 = constructor_bor(ctx, v2.0, v774, v99.1);
                                                                                                // Rule at src/opts/bitops.isle line 384.
                                                                                                returns.extend(Some(v775));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v779 = constructor_bxor(ctx, v2.0, v286.1, v286.0);
                                                                                                let v780 = constructor_bor(ctx, v2.0, v779, v99.1);
                                                                                                // Rule at src/opts/bitops.isle line 399.
                                                                                                returns.extend(Some(v780));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                        if v135.0 == v286.1 {
                                                                                            if v135.1 == v286.0 {
                                                                                                let v779 = constructor_bxor(ctx, v2.0, v286.1, v286.0);
                                                                                                let v780 = constructor_bor(ctx, v2.0, v779, v99.1);
                                                                                                // Rule at src/opts/bitops.isle line 389.
                                                                                                returns.extend(Some(v780));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v774 = constructor_bxor(ctx, v2.0, v286.0, v286.1);
                                                                                                let v775 = constructor_bor(ctx, v2.0, v774, v99.1);
                                                                                                // Rule at src/opts/bitops.isle line 394.
                                                                                                returns.extend(Some(v775));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let mut v109 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                                        let mut v109 = v109.into_context_iter();
                                                                        while let Some(v110) = v109.next(ctx) {
                                                                            if let &InstructionData::Binary {
                                                                                opcode: ref v268,
                                                                                args: ref v269,
                                                                            } = &v110.1 {
                                                                                if let &Opcode::Bxor = v268 {
                                                                                    if v2.0 == v110.0 {
                                                                                        let v135 = C::unpack_value_array_2(ctx, v134);
                                                                                        let v270 = C::unpack_value_array_2(ctx, v269);
                                                                                        if v135.0 == v270.0 {
                                                                                            if v135.1 == v270.1 {
                                                                                                let v777 = constructor_bxor(ctx, v2.0, v270.0, v270.1);
                                                                                                let v778 = constructor_bor(ctx, v2.0, v777, v99.0);
                                                                                                // Rule at src/opts/bitops.isle line 386.
                                                                                                returns.extend(Some(v778));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v781 = constructor_bxor(ctx, v2.0, v270.1, v270.0);
                                                                                                let v782 = constructor_bor(ctx, v2.0, v781, v99.0);
                                                                                                // Rule at src/opts/bitops.isle line 401.
                                                                                                returns.extend(Some(v782));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                        if v135.0 == v270.1 {
                                                                                            if v135.1 == v270.0 {
                                                                                                let v781 = constructor_bxor(ctx, v2.0, v270.1, v270.0);
                                                                                                let v782 = constructor_bor(ctx, v2.0, v781, v99.0);
                                                                                                // Rule at src/opts/bitops.isle line 391.
                                                                                                returns.extend(Some(v782));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v777 = constructor_bxor(ctx, v2.0, v270.0, v270.1);
                                                                                                let v778 = constructor_bor(ctx, v2.0, v777, v99.0);
                                                                                                // Rule at src/opts/bitops.isle line 396.
                                                                                                returns.extend(Some(v778));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let v135 = C::unpack_value_array_2(ctx, v134);
                                                                        let mut v258 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v135.1, &mut v258);
                                                                        let mut v258 = v258.into_context_iter();
                                                                        while let Some(v259) = v258.next(ctx) {
                                                                            if let &InstructionData::Binary {
                                                                                opcode: ref v262,
                                                                                args: ref v263,
                                                                            } = &v259.1 {
                                                                                if let &Opcode::Bxor = v262 {
                                                                                    if v2.0 == v259.0 {
                                                                                        let v264 = C::unpack_value_array_2(ctx, v263);
                                                                                        if v99.0 == v264.0 {
                                                                                            if v99.1 == v264.1 {
                                                                                                let v238 = constructor_bxor(ctx, v2.0, v99.0, v99.1);
                                                                                                let v776 = constructor_bor(ctx, v2.0, v238, v135.0);
                                                                                                // Rule at src/opts/bitops.isle line 385.
                                                                                                returns.extend(Some(v776));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v239 = constructor_bxor(ctx, v2.0, v99.1, v99.0);
                                                                                                let v784 = constructor_bor(ctx, v2.0, v239, v135.0);
                                                                                                // Rule at src/opts/bitops.isle line 400.
                                                                                                returns.extend(Some(v784));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                        if v99.1 == v264.0 {
                                                                                            if v99.0 == v264.1 {
                                                                                                let v238 = constructor_bxor(ctx, v2.0, v99.0, v99.1);
                                                                                                let v776 = constructor_bor(ctx, v2.0, v238, v135.0);
                                                                                                // Rule at src/opts/bitops.isle line 390.
                                                                                                returns.extend(Some(v776));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v239 = constructor_bxor(ctx, v2.0, v99.1, v99.0);
                                                                                                let v784 = constructor_bor(ctx, v2.0, v239, v135.0);
                                                                                                // Rule at src/opts/bitops.isle line 395.
                                                                                                returns.extend(Some(v784));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let mut v274 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v135.0, &mut v274);
                                                                        let mut v274 = v274.into_context_iter();
                                                                        while let Some(v275) = v274.next(ctx) {
                                                                            if let &InstructionData::Binary {
                                                                                opcode: ref v278,
                                                                                args: ref v279,
                                                                            } = &v275.1 {
                                                                                if let &Opcode::Bxor = v278 {
                                                                                    if v2.0 == v275.0 {
                                                                                        let v280 = C::unpack_value_array_2(ctx, v279);
                                                                                        if v99.0 == v280.0 {
                                                                                            if v99.1 == v280.1 {
                                                                                                let v238 = constructor_bxor(ctx, v2.0, v99.0, v99.1);
                                                                                                let v773 = constructor_bor(ctx, v2.0, v238, v135.1);
                                                                                                // Rule at src/opts/bitops.isle line 383.
                                                                                                returns.extend(Some(v773));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v239 = constructor_bxor(ctx, v2.0, v99.1, v99.0);
                                                                                                let v783 = constructor_bor(ctx, v2.0, v239, v135.1);
                                                                                                // Rule at src/opts/bitops.isle line 398.
                                                                                                returns.extend(Some(v783));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                        if v99.1 == v280.0 {
                                                                                            if v99.0 == v280.1 {
                                                                                                let v238 = constructor_bxor(ctx, v2.0, v99.0, v99.1);
                                                                                                let v773 = constructor_bor(ctx, v2.0, v238, v135.1);
                                                                                                // Rule at src/opts/bitops.isle line 388.
                                                                                                returns.extend(Some(v773));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v239 = constructor_bxor(ctx, v2.0, v99.1, v99.0);
                                                                                                let v783 = constructor_bor(ctx, v2.0, v239, v135.1);
                                                                                                // Rule at src/opts/bitops.isle line 393.
                                                                                                returns.extend(Some(v783));
                                                                                                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 v135 = C::unpack_value_array_2(ctx, v134);
                                                                    if v30 == v135.0 {
                                                                        let v828 = constructor_band(ctx, v2.0, v135.1, v30);
                                                                        let v829 = constructor_bnot(ctx, v2.0, v828);
                                                                        // Rule at src/opts/bitops.isle line 487.
                                                                        returns.extend(Some(v829));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v30 == v135.1 {
                                                                        let v825 = constructor_band(ctx, v2.0, v135.0, v30);
                                                                        let v826 = constructor_bnot(ctx, v2.0, v825);
                                                                        // Rule at src/opts/bitops.isle line 485.
                                                                        returns.extend(Some(v826));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let v135 = C::unpack_value_array_2(ctx, v134);
                                                let mut v258 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v135.1, &mut v258);
                                                let mut v258 = v258.into_context_iter();
                                                while let Some(v259) = v258.next(ctx) {
                                                    match &v259.1 {
                                                        &InstructionData::Binary {
                                                            opcode: ref v262,
                                                            args: ref v263,
                                                        } => {
                                                            match v262 {
                                                                &Opcode::Band => {
                                                                    if v2.0 == v259.0 {
                                                                        let v264 = C::unpack_value_array_2(ctx, v263);
                                                                        if v7.0 == v264.0 {
                                                                            let v350 = constructor_bor(ctx, v2.0, v135.0, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 517.
                                                                            returns.extend(Some(v350));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.0 == v264.1 {
                                                                            let v350 = constructor_bor(ctx, v2.0, v135.0, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 521.
                                                                            returns.extend(Some(v350));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Bxor => {
                                                                    if v2.0 == v259.0 {
                                                                        let v264 = C::unpack_value_array_2(ctx, v263);
                                                                        if v7.0 == v264.0 {
                                                                            let v714 = constructor_bxor(ctx, v2.0, v264.1, v135.0);
                                                                            let v715 = constructor_bor(ctx, v2.0, v714, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 296.
                                                                            returns.extend(Some(v715));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.0 == v264.1 {
                                                                            let v722 = constructor_bxor(ctx, v2.0, v264.0, v135.0);
                                                                            let v723 = constructor_bor(ctx, v2.0, v722, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 300.
                                                                            returns.extend(Some(v723));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v627,
                                                            arg: v628,
                                                        } => {
                                                            if let &Opcode::Bnot = v627 {
                                                                if v7.0 == v628 {
                                                                    if v2.0 == v259.0 {
                                                                        let v747 = constructor_bnot(ctx, v2.0, v135.0);
                                                                        let v886 = constructor_bor(ctx, v2.0, v7.0, v747);
                                                                        // Rule at src/opts/bitops.isle line 598.
                                                                        returns.extend(Some(v886));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let mut v274 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v135.0, &mut v274);
                                                let mut v274 = v274.into_context_iter();
                                                while let Some(v275) = v274.next(ctx) {
                                                    match &v275.1 {
                                                        &InstructionData::Binary {
                                                            opcode: ref v278,
                                                            args: ref v279,
                                                        } => {
                                                            match v278 {
                                                                &Opcode::Band => {
                                                                    if v2.0 == v275.0 {
                                                                        let v280 = C::unpack_value_array_2(ctx, v279);
                                                                        if v7.0 == v280.0 {
                                                                            let v862 = constructor_bor(ctx, v2.0, v135.1, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 519.
                                                                            returns.extend(Some(v862));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.0 == v280.1 {
                                                                            let v862 = constructor_bor(ctx, v2.0, v135.1, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 523.
                                                                            returns.extend(Some(v862));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Bxor => {
                                                                    if v2.0 == v275.0 {
                                                                        let v280 = C::unpack_value_array_2(ctx, v279);
                                                                        if v7.0 == v280.0 {
                                                                            let v710 = constructor_bxor(ctx, v2.0, v280.1, v135.1);
                                                                            let v711 = constructor_bor(ctx, v2.0, v710, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 294.
                                                                            returns.extend(Some(v711));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.0 == v280.1 {
                                                                            let v718 = constructor_bxor(ctx, v2.0, v280.0, v135.1);
                                                                            let v719 = constructor_bor(ctx, v2.0, v718, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 298.
                                                                            returns.extend(Some(v719));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v630,
                                                            arg: v631,
                                                        } => {
                                                            if let &Opcode::Bnot = v630 {
                                                                if v7.0 == v631 {
                                                                    if v2.0 == v275.0 {
                                                                        let v744 = constructor_bnot(ctx, v2.0, v135.1);
                                                                        let v884 = constructor_bor(ctx, v2.0, v7.0, v744);
                                                                        // Rule at src/opts/bitops.isle line 596.
                                                                        returns.extend(Some(v884));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                if v7.0 == v135.0 {
                                                    let v622 = constructor_bor(ctx, v2.0, v7.0, v135.1);
                                                    // Rule at src/opts/bitops.isle line 404.
                                                    returns.extend(Some(v622));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.0 == v135.1 {
                                                    let v785 = constructor_bor(ctx, v2.0, v7.0, v135.0);
                                                    // Rule at src/opts/bitops.isle line 406.
                                                    returns.extend(Some(v785));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        &Opcode::Ishl => {
                                            let v339 = C::ty_int(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::Binary {
                                                            opcode: ref v97,
                                                            args: ref v98,
                                                        } = &v19.1 {
                                                            if let &Opcode::Ushr = v97 {
                                                                if v11.0 == v19.0 {
                                                                    let v99 = C::unpack_value_array_2(ctx, v98);
                                                                    let v135 = C::unpack_value_array_2(ctx, v134);
                                                                    if v99.0 == v135.0 {
                                                                        let mut v109 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                                        let mut v109 = v109.into_context_iter();
                                                                        while let Some(v110) = v109.next(ctx) {
                                                                            if let &InstructionData::UnaryImm {
                                                                                opcode: ref v127,
                                                                                imm: v128,
                                                                            } = &v110.1 {
                                                                                if let &Opcode::Iconst = v127 {
                                                                                    let mut v258 = C::inst_data_value_etor_returns::default();
                                                                                    C::inst_data_value_etor(ctx, v135.1, &mut v258);
                                                                                    let mut v258 = v258.into_context_iter();
                                                                                    while let Some(v259) = v258.next(ctx) {
                                                                                        if let &InstructionData::UnaryImm {
                                                                                            opcode: ref v1124,
                                                                                            imm: v1125,
                                                                                        } = &v259.1 {
                                                                                            if let &Opcode::Iconst = v1124 {
                                                                                                let v351 = C::u64_from_imm64(ctx, v128);
                                                                                                let v1889 = C::lane_type(ctx, v340);
                                                                                                let v1890 = C::ty_bits_u64(ctx, v1889);
                                                                                                let v1393 = C::u64_from_imm64(ctx, v1125);
                                                                                                let v1894 = C::u64_wrapping_sub(ctx, v1890, v1393);
                                                                                                let v1895 = C::u64_eq(ctx, v351, v1894);
                                                                                                if v1895 == true {
                                                                                                    let v1896 = constructor_rotl(ctx, v340, v99.0, v135.1);
                                                                                                    // Rule at src/opts/shifts.isle line 284.
                                                                                                    returns.extend(Some(v1896));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Ushr => {
                                            let v339 = C::ty_int(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::Binary {
                                                            opcode: ref v97,
                                                            args: ref v98,
                                                        } = &v19.1 {
                                                            if let &Opcode::Ishl = v97 {
                                                                if v11.0 == v19.0 {
                                                                    let v99 = C::unpack_value_array_2(ctx, v98);
                                                                    let v135 = C::unpack_value_array_2(ctx, v134);
                                                                    if v99.0 == v135.0 {
                                                                        let mut v109 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                                        let mut v109 = v109.into_context_iter();
                                                                        while let Some(v110) = v109.next(ctx) {
                                                                            if let &InstructionData::UnaryImm {
                                                                                opcode: ref v127,
                                                                                imm: v128,
                                                                            } = &v110.1 {
                                                                                if let &Opcode::Iconst = v127 {
                                                                                    let mut v258 = C::inst_data_value_etor_returns::default();
                                                                                    C::inst_data_value_etor(ctx, v135.1, &mut v258);
                                                                                    let mut v258 = v258.into_context_iter();
                                                                                    while let Some(v259) = v258.next(ctx) {
                                                                                        if let &InstructionData::UnaryImm {
                                                                                            opcode: ref v1124,
                                                                                            imm: v1125,
                                                                                        } = &v259.1 {
                                                                                            if let &Opcode::Iconst = v1124 {
                                                                                                let v1393 = C::u64_from_imm64(ctx, v1125);
                                                                                                let v1889 = C::lane_type(ctx, v340);
                                                                                                let v1890 = C::ty_bits_u64(ctx, v1889);
                                                                                                let v351 = C::u64_from_imm64(ctx, v128);
                                                                                                let v1891 = C::u64_wrapping_sub(ctx, v1890, v351);
                                                                                                let v1892 = C::u64_eq(ctx, v1393, v1891);
                                                                                                if v1892 == true {
                                                                                                    let v1893 = constructor_rotl(ctx, v340, v99.0, v99.1);
                                                                                                    // Rule at src/opts/shifts.isle line 279.
                                                                                                    returns.extend(Some(v1893));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::IntCompare {
                                    opcode: ref v755,
                                    args: ref v756,
                                    cond: ref v757,
                                } => {
                                    if let &Opcode::Icmp = v755 {
                                        let mut v18 = C::inst_data_value_etor_returns::default();
                                        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 v749,
                                                args: ref v750,
                                                cond: ref v751,
                                            } = &v19.1 {
                                                if let &Opcode::Icmp = v749 {
                                                    if v11.0 == v19.0 {
                                                        match v751 {
                                                            &IntCC::Equal => {
                                                                match v757 {
                                                                    &IntCC::SignedGreaterThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v752 = C::unpack_value_array_2(ctx, v750);
                                                                            let v758 = C::unpack_value_array_2(ctx, v756);
                                                                            if v752.0 == v758.0 {
                                                                                if v752.1 == v758.1 {
                                                                                    let v772 = constructor_sle(ctx, v2.0, v752.1, v752.0);
                                                                                    // Rule at src/opts/bitops.isle line 380.
                                                                                    returns.extend(Some(v772));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                            if v752.0 == v758.1 {
                                                                                if v752.1 == v758.0 {
                                                                                    let v771 = constructor_sle(ctx, v2.0, v752.0, v752.1);
                                                                                    // Rule at src/opts/bitops.isle line 378.
                                                                                    returns.extend(Some(v771));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedLessThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v752 = C::unpack_value_array_2(ctx, v750);
                                                                            let v758 = C::unpack_value_array_2(ctx, v756);
                                                                            if v752.0 == v758.0 {
                                                                                if v752.1 == v758.1 {
                                                                                    let v771 = constructor_sle(ctx, v2.0, v752.0, v752.1);
                                                                                    // Rule at src/opts/bitops.isle line 372.
                                                                                    returns.extend(Some(v771));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                            if v752.0 == v758.1 {
                                                                                if v752.1 == v758.0 {
                                                                                    let v772 = constructor_sle(ctx, v2.0, v752.1, v752.0);
                                                                                    // Rule at src/opts/bitops.isle line 374.
                                                                                    returns.extend(Some(v772));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedGreaterThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v752 = C::unpack_value_array_2(ctx, v750);
                                                                            let v758 = C::unpack_value_array_2(ctx, v756);
                                                                            if v752.0 == v758.0 {
                                                                                if v752.1 == v758.1 {
                                                                                    let v770 = constructor_ule(ctx, v2.0, v752.1, v752.0);
                                                                                    // Rule at src/opts/bitops.isle line 368.
                                                                                    returns.extend(Some(v770));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                            if v752.0 == v758.1 {
                                                                                if v752.1 == v758.0 {
                                                                                    let v769 = constructor_ule(ctx, v2.0, v752.0, v752.1);
                                                                                    // Rule at src/opts/bitops.isle line 366.
                                                                                    returns.extend(Some(v769));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v752 = C::unpack_value_array_2(ctx, v750);
                                                                            let v758 = C::unpack_value_array_2(ctx, v756);
                                                                            if v752.0 == v758.0 {
                                                                                if v752.1 == v758.1 {
                                                                                    let v769 = constructor_ule(ctx, v2.0, v752.0, v752.1);
                                                                                    // Rule at src/opts/bitops.isle line 360.
                                                                                    returns.extend(Some(v769));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                            if v752.0 == v758.1 {
                                                                                if v752.1 == v758.0 {
                                                                                    let v770 = constructor_ule(ctx, v2.0, v752.1, v752.0);
                                                                                    // Rule at src/opts/bitops.isle line 362.
                                                                                    returns.extend(Some(v770));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                            &IntCC::SignedGreaterThan => {
                                                                match v757 {
                                                                    &IntCC::Equal => {
                                                                        if v2.0 == v11.0 {
                                                                            let v752 = C::unpack_value_array_2(ctx, v750);
                                                                            let v758 = C::unpack_value_array_2(ctx, v756);
                                                                            if v752.0 == v758.0 {
                                                                                if v752.1 == v758.1 {
                                                                                    let v772 = constructor_sle(ctx, v2.0, v752.1, v752.0);
                                                                                    // Rule at src/opts/bitops.isle line 379.
                                                                                    returns.extend(Some(v772));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                            if v752.0 == v758.1 {
                                                                                if v752.1 == v758.0 {
                                                                                    let v772 = constructor_sle(ctx, v2.0, v752.1, v752.0);
                                                                                    // Rule at src/opts/bitops.isle line 377.
                                                                                    returns.extend(Some(v772));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedGreaterThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v752 = C::unpack_value_array_2(ctx, v750);
                                                                            let v758 = C::unpack_value_array_2(ctx, v756);
                                                                            if v752.0 == v758.1 {
                                                                                if v752.1 == v758.0 {
                                                                                    let v762 = constructor_ne(ctx, v2.0, v752.1, v752.0);
                                                                                    // Rule at src/opts/bitops.isle line 335.
                                                                                    returns.extend(Some(v762));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    let v761 = constructor_ne(ctx, v2.0, v752.0, v752.1);
                                                                                    // Rule at src/opts/bitops.isle line 336.
                                                                                    returns.extend(Some(v761));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedLessThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v752 = C::unpack_value_array_2(ctx, v750);
                                                                            let v758 = C::unpack_value_array_2(ctx, v756);
                                                                            if v752.0 == v758.0 {
                                                                                if v752.1 == v758.1 {
                                                                                    let v761 = constructor_ne(ctx, v2.0, v752.0, v752.1);
                                                                                    // Rule at src/opts/bitops.isle line 332.
                                                                                    returns.extend(Some(v761));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    let v762 = constructor_ne(ctx, v2.0, v752.1, v752.0);
                                                                                    // Rule at src/opts/bitops.isle line 337.
                                                                                    returns.extend(Some(v762));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                            &IntCC::SignedLessThan => {
                                                                match v757 {
                                                                    &IntCC::Equal => {
                                                                        if v2.0 == v11.0 {
                                                                            let v752 = C::unpack_value_array_2(ctx, v750);
                                                                            let v758 = C::unpack_value_array_2(ctx, v756);
                                                                            if v752.0 == v758.0 {
                                                                                if v752.1 == v758.1 {
                                                                                    let v771 = constructor_sle(ctx, v2.0, v752.0, v752.1);
                                                                                    // Rule at src/opts/bitops.isle line 371.
                                                                                    returns.extend(Some(v771));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                            if v752.0 == v758.1 {
                                                                                if v752.1 == v758.0 {
                                                                                    let v771 = constructor_sle(ctx, v2.0, v752.0, v752.1);
                                                                                    // Rule at src/opts/bitops.isle line 373.
                                                                                    returns.extend(Some(v771));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedGreaterThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v752 = C::unpack_value_array_2(ctx, v750);
                                                                            let v758 = C::unpack_value_array_2(ctx, v756);
                                                                            if v752.0 == v758.0 {
                                                                                if v752.1 == v758.1 {
                                                                                    let v761 = constructor_ne(ctx, v2.0, v752.0, v752.1);
                                                                                    // Rule at src/opts/bitops.isle line 331.
                                                                                    returns.extend(Some(v761));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    let v762 = constructor_ne(ctx, v2.0, v752.1, v752.0);
                                                                                    // Rule at src/opts/bitops.isle line 338.
                                                                                    returns.extend(Some(v762));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedLessThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v752 = C::unpack_value_array_2(ctx, v750);
                                                                            let v758 = C::unpack_value_array_2(ctx, v756);
                                                                            if v752.0 == v758.1 {
                                                                                if v752.1 == v758.0 {
                                                                                    let v761 = constructor_ne(ctx, v2.0, v752.0, v752.1);
                                                                                    // Rule at src/opts/bitops.isle line 333.
                                                                                    returns.extend(Some(v761));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    let v762 = constructor_ne(ctx, v2.0, v752.1, v752.0);
                                                                                    // Rule at src/opts/bitops.isle line 334.
                                                                                    returns.extend(Some(v762));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                            &IntCC::UnsignedGreaterThan => {
                                                                match v757 {
                                                                    &IntCC::Equal => {
                                                                        if v2.0 == v11.0 {
                                                                            let v752 = C::unpack_value_array_2(ctx, v750);
                                                                            let v758 = C::unpack_value_array_2(ctx, v756);
                                                                            if v752.0 == v758.0 {
                                                                                if v752.1 == v758.1 {
                                                                                    let v770 = constructor_ule(ctx, v2.0, v752.1, v752.0);
                                                                                    // Rule at src/opts/bitops.isle line 367.
                                                                                    returns.extend(Some(v770));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                            if v752.0 == v758.1 {
                                                                                if v752.1 == v758.0 {
                                                                                    let v770 = constructor_ule(ctx, v2.0, v752.1, v752.0);
                                                                                    // Rule at src/opts/bitops.isle line 365.
                                                                                    returns.extend(Some(v770));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedGreaterThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v752 = C::unpack_value_array_2(ctx, v750);
                                                                            let v758 = C::unpack_value_array_2(ctx, v756);
                                                                            if v752.0 == v758.1 {
                                                                                if v752.1 == v758.0 {
                                                                                    let v762 = constructor_ne(ctx, v2.0, v752.1, v752.0);
                                                                                    // Rule at src/opts/bitops.isle line 345.
                                                                                    returns.extend(Some(v762));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    let v761 = constructor_ne(ctx, v2.0, v752.0, v752.1);
                                                                                    // Rule at src/opts/bitops.isle line 346.
                                                                                    returns.extend(Some(v761));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v752 = C::unpack_value_array_2(ctx, v750);
                                                                            let v758 = C::unpack_value_array_2(ctx, v756);
                                                                            if v752.0 == v758.0 {
                                                                                if v752.1 == v758.1 {
                                                                                    let v761 = constructor_ne(ctx, v2.0, v752.0, v752.1);
                                                                                    // Rule at src/opts/bitops.isle line 342.
                                                                                    returns.extend(Some(v761));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    let v762 = constructor_ne(ctx, v2.0, v752.1, v752.0);
                                                                                    // Rule at src/opts/bitops.isle line 347.
                                                                                    returns.extend(Some(v762));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                            &IntCC::UnsignedLessThan => {
                                                                match v757 {
                                                                    &IntCC::Equal => {
                                                                        if v2.0 == v11.0 {
                                                                            let v752 = C::unpack_value_array_2(ctx, v750);
                                                                            let v758 = C::unpack_value_array_2(ctx, v756);
                                                                            if v752.0 == v758.0 {
                                                                                if v752.1 == v758.1 {
                                                                                    let v769 = constructor_ule(ctx, v2.0, v752.0, v752.1);
                                                                                    // Rule at src/opts/bitops.isle line 359.
                                                                                    returns.extend(Some(v769));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                            if v752.0 == v758.1 {
                                                                                if v752.1 == v758.0 {
                                                                                    let v769 = constructor_ule(ctx, v2.0, v752.0, v752.1);
                                                                                    // Rule at src/opts/bitops.isle line 361.
                                                                                    returns.extend(Some(v769));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedGreaterThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v752 = C::unpack_value_array_2(ctx, v750);
                                                                            let v758 = C::unpack_value_array_2(ctx, v756);
                                                                            if v752.0 == v758.0 {
                                                                                if v752.1 == v758.1 {
                                                                                    let v761 = constructor_ne(ctx, v2.0, v752.0, v752.1);
                                                                                    // Rule at src/opts/bitops.isle line 341.
                                                                                    returns.extend(Some(v761));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    let v762 = constructor_ne(ctx, v2.0, v752.1, v752.0);
                                                                                    // Rule at src/opts/bitops.isle line 348.
                                                                                    returns.extend(Some(v762));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v752 = C::unpack_value_array_2(ctx, v750);
                                                                            let v758 = C::unpack_value_array_2(ctx, v756);
                                                                            if v752.0 == v758.1 {
                                                                                if v752.1 == v758.0 {
                                                                                    let v761 = constructor_ne(ctx, v2.0, v752.0, v752.1);
                                                                                    // Rule at src/opts/bitops.isle line 343.
                                                                                    returns.extend(Some(v761));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    let v762 = constructor_ne(ctx, v2.0, v752.1, v752.0);
                                                                                    // Rule at src/opts/bitops.isle line 344.
                                                                                    returns.extend(Some(v762));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                        let v334 = C::fits_in_64(ctx, v2.0);
                                                        if let Some(v335) = v334 {
                                                            if v11.0 == v335 {
                                                                let v1465 = constructor_intcc_comparable(ctx, v751, v757);
                                                                if let Some(v1466) = v1465 {
                                                                    let v752 = C::unpack_value_array_2(ctx, v750);
                                                                    let v758 = C::unpack_value_array_2(ctx, v756);
                                                                    if v752.0 == v758.0 {
                                                                        if v752.1 == v758.1 {
                                                                            let v1467 = constructor_decompose_intcc(ctx, v751);
                                                                            let v1468 = constructor_decompose_intcc(ctx, v757);
                                                                            let v1471 = C::u64_or(ctx, v1467, v1468);
                                                                            let v1472 = constructor_compose_icmp(ctx, v335, v1471, v1466, v752.0, v752.1);
                                                                            // Rule at src/opts/icmp.isle line 183.
                                                                            returns.extend(Some(v1472));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v26,
                                    arg: v27,
                                } => {
                                    match v26 {
                                        &Opcode::Splat => {
                                            let v1985 = C::ty_vector_not_float(ctx, v2.0);
                                            if let Some(v1986) = v1985 {
                                                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 v1849 = C::lane_type(ctx, v2.0);
                                                                    let v1989 = constructor_bor(ctx, v1849, v30, v27);
                                                                    let v1990 = constructor_splat(ctx, v2.0, v1989);
                                                                    // Rule at src/opts/vector.isle line 18.
                                                                    returns.extend(Some(v1990));
                                                                    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 v97,
                                                            args: ref v98,
                                                        } => {
                                                            match v97 {
                                                                &Opcode::Band => {
                                                                    if v2.0 == v19.0 {
                                                                        let mut v639 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v27, &mut v639);
                                                                        let mut v639 = v639.into_context_iter();
                                                                        while let Some(v640) = v639.next(ctx) {
                                                                            if let &InstructionData::Binary {
                                                                                opcode: ref v643,
                                                                                args: ref v644,
                                                                            } = &v640.1 {
                                                                                match v643 {
                                                                                    &Opcode::Bor => {
                                                                                        if v2.0 == v640.0 {
                                                                                            let v99 = C::unpack_value_array_2(ctx, v98);
                                                                                            let v645 = C::unpack_value_array_2(ctx, v644);
                                                                                            if v99.0 == v645.0 {
                                                                                                if v99.1 == v645.1 {
                                                                                                    let v238 = constructor_bxor(ctx, v2.0, v99.0, v99.1);
                                                                                                    let v648 = constructor_bnot(ctx, v2.0, v238);
                                                                                                    // Rule at src/opts/bitops.isle line 671.
                                                                                                    returns.extend(Some(v648));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    let v239 = constructor_bxor(ctx, v2.0, v99.1, v99.0);
                                                                                                    let v662 = constructor_bnot(ctx, v2.0, v239);
                                                                                                    // Rule at src/opts/bitops.isle line 677.
                                                                                                    returns.extend(Some(v662));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                                let mut v109 = C::inst_data_value_etor_returns::default();
                                                                                                C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                                                                let mut v109 = v109.into_context_iter();
                                                                                                while let Some(v110) = v109.next(ctx) {
                                                                                                    if let &InstructionData::Unary {
                                                                                                        opcode: ref v113,
                                                                                                        arg: v114,
                                                                                                    } = &v110.1 {
                                                                                                        if let &Opcode::Bnot = v113 {
                                                                                                            if v114 == v645.1 {
                                                                                                                if v2.0 == v110.0 {
                                                                                                                    let v926 = constructor_bnot(ctx, v2.0, v114);
                                                                                                                    // Rule at src/opts/bitops.isle line 657.
                                                                                                                    returns.extend(Some(v926));
                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                            if v99.0 == v645.1 {
                                                                                                if v99.1 == v645.0 {
                                                                                                    let v238 = constructor_bxor(ctx, v2.0, v99.0, v99.1);
                                                                                                    let v648 = constructor_bnot(ctx, v2.0, v238);
                                                                                                    // Rule at src/opts/bitops.isle line 673.
                                                                                                    returns.extend(Some(v648));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    let v239 = constructor_bxor(ctx, v2.0, v99.1, v99.0);
                                                                                                    let v662 = constructor_bnot(ctx, v2.0, v239);
                                                                                                    // Rule at src/opts/bitops.isle line 675.
                                                                                                    returns.extend(Some(v662));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                                let mut v109 = C::inst_data_value_etor_returns::default();
                                                                                                C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                                                                let mut v109 = v109.into_context_iter();
                                                                                                while let Some(v110) = v109.next(ctx) {
                                                                                                    if let &InstructionData::Unary {
                                                                                                        opcode: ref v113,
                                                                                                        arg: v114,
                                                                                                    } = &v110.1 {
                                                                                                        if let &Opcode::Bnot = v113 {
                                                                                                            if v114 == v645.0 {
                                                                                                                if v2.0 == v110.0 {
                                                                                                                    let v926 = constructor_bnot(ctx, v2.0, v114);
                                                                                                                    // Rule at src/opts/bitops.isle line 655.
                                                                                                                    returns.extend(Some(v926));
                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                            let mut v102 = C::inst_data_value_etor_returns::default();
                                                                                            C::inst_data_value_etor(ctx, v99.0, &mut v102);
                                                                                            let mut v102 = v102.into_context_iter();
                                                                                            while let Some(v103) = v102.next(ctx) {
                                                                                                if let &InstructionData::Unary {
                                                                                                    opcode: ref v106,
                                                                                                    arg: v107,
                                                                                                } = &v103.1 {
                                                                                                    if let &Opcode::Bnot = v106 {
                                                                                                        if v2.0 == v103.0 {
                                                                                                            if v107 == v645.0 {
                                                                                                                if v99.1 == v645.1 {
                                                                                                                    let v925 = constructor_bnot(ctx, v2.0, v107);
                                                                                                                    // Rule at src/opts/bitops.isle line 651.
                                                                                                                    returns.extend(Some(v925));
                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                }
                                                                                                            }
                                                                                                            if v107 == v645.1 {
                                                                                                                if v99.1 == v645.0 {
                                                                                                                    let v925 = constructor_bnot(ctx, v2.0, v107);
                                                                                                                    // Rule at src/opts/bitops.isle line 653.
                                                                                                                    returns.extend(Some(v925));
                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                    &Opcode::Bxor => {
                                                                                        if v2.0 == v640.0 {
                                                                                            let v99 = C::unpack_value_array_2(ctx, v98);
                                                                                            let v645 = C::unpack_value_array_2(ctx, v644);
                                                                                            if v99.0 == v645.0 {
                                                                                                if v99.1 == v645.1 {
                                                                                                    let v238 = constructor_bxor(ctx, v2.0, v99.0, v99.1);
                                                                                                    let v648 = constructor_bnot(ctx, v2.0, v238);
                                                                                                    // Rule at src/opts/bitops.isle line 229.
                                                                                                    returns.extend(Some(v648));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    let v239 = constructor_bxor(ctx, v2.0, v99.1, v99.0);
                                                                                                    let v662 = constructor_bnot(ctx, v2.0, v239);
                                                                                                    // Rule at src/opts/bitops.isle line 235.
                                                                                                    returns.extend(Some(v662));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                            if v99.0 == v645.1 {
                                                                                                if v99.1 == v645.0 {
                                                                                                    let v238 = constructor_bxor(ctx, v2.0, v99.0, v99.1);
                                                                                                    let v648 = constructor_bnot(ctx, v2.0, v238);
                                                                                                    // Rule at src/opts/bitops.isle line 231.
                                                                                                    returns.extend(Some(v648));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    let v239 = constructor_bxor(ctx, v2.0, v99.1, v99.0);
                                                                                                    let v662 = constructor_bnot(ctx, v2.0, v239);
                                                                                                    // Rule at src/opts/bitops.isle line 233.
                                                                                                    returns.extend(Some(v662));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                    _ => {}
                                                                                }
                                                                            }
                                                                        }
                                                                        let v99 = C::unpack_value_array_2(ctx, v98);
                                                                        if v27 == v99.0 {
                                                                            let v633 = constructor_bnot(ctx, v2.0, v99.0);
                                                                            let v634 = constructor_bor(ctx, v2.0, v99.1, v633);
                                                                            // Rule at src/opts/bitops.isle line 220.
                                                                            returns.extend(Some(v634));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v27 == v99.1 {
                                                                            let v349 = constructor_bor(ctx, v2.0, v99.0, v7.1);
                                                                            // Rule at src/opts/bitops.isle line 44.
                                                                            returns.extend(Some(v349));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Bxor => {
                                                                    if v2.0 == v19.0 {
                                                                        let v99 = C::unpack_value_array_2(ctx, v98);
                                                                        if v27 == v99.0 {
                                                                            let v242 = constructor_band(ctx, v2.0, v99.1, v99.0);
                                                                            let v827 = constructor_bnot(ctx, v2.0, v242);
                                                                            // Rule at src/opts/bitops.isle line 486.
                                                                            returns.extend(Some(v827));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v27 == v99.1 {
                                                                            let v138 = constructor_band(ctx, v2.0, v99.0, v99.1);
                                                                            let v824 = constructor_bnot(ctx, v2.0, v138);
                                                                            // Rule at src/opts/bitops.isle line 484.
                                                                            returns.extend(Some(v824));
                                                                            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 v704 = constructor_band(ctx, v2.0, v30, v27);
                                                                    let v705 = constructor_bnot(ctx, v2.0, v704);
                                                                    // Rule at src/opts/bitops.isle line 289.
                                                                    returns.extend(Some(v705));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    let v706 = constructor_band(ctx, v2.0, v27, v30);
                                                                    let v707 = constructor_bnot(ctx, v2.0, v706);
                                                                    // Rule at src/opts/bitops.isle line 290.
                                                                    returns.extend(Some(v707));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let mut v639 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v27, &mut v639);
                                                let mut v639 = v639.into_context_iter();
                                                while let Some(v640) = v639.next(ctx) {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v643,
                                                        args: ref v644,
                                                    } = &v640.1 {
                                                        match v643 {
                                                            &Opcode::Bor => {
                                                                if v2.0 == v640.0 {
                                                                    let v645 = C::unpack_value_array_2(ctx, v644);
                                                                    if v7.0 == v645.0 {
                                                                        let v736 = constructor_bnot(ctx, v2.0, v645.1);
                                                                        let v737 = constructor_bor(ctx, v2.0, v7.0, v736);
                                                                        // Rule at src/opts/bitops.isle line 315.
                                                                        returns.extend(Some(v737));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v7.0 == v645.1 {
                                                                        let v732 = constructor_bnot(ctx, v2.0, v645.0);
                                                                        let v733 = constructor_bor(ctx, v2.0, v7.0, v732);
                                                                        // Rule at src/opts/bitops.isle line 313.
                                                                        returns.extend(Some(v733));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Bxor => {
                                                                if v2.0 == v640.0 {
                                                                    let v645 = C::unpack_value_array_2(ctx, v644);
                                                                    if v7.0 == v645.0 {
                                                                        let v736 = constructor_bnot(ctx, v2.0, v645.1);
                                                                        let v737 = constructor_bor(ctx, v2.0, v7.0, v736);
                                                                        // Rule at src/opts/bitops.isle line 590.
                                                                        returns.extend(Some(v737));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v7.0 == v645.1 {
                                                                        let v732 = constructor_bnot(ctx, v2.0, v645.0);
                                                                        let v733 = constructor_bor(ctx, v2.0, v7.0, v732);
                                                                        // Rule at src/opts/bitops.isle line 592.
                                                                        returns.extend(Some(v733));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                    }
                                                }
                                            }
                                            let v343 = C::ty_int_vec128(ctx, v2.0);
                                            if let Some(v344) = v343 {
                                                if v11.0 == v344 {
                                                    if v7.0 == v27 {
                                                        let v345 = constructor_iconst_s(ctx, v344, -1_i64);
                                                        let v346 = C::subsume(ctx, v345);
                                                        // Rule at src/opts/bitops.isle line 24.
                                                        returns.extend(Some(v346));
                                                        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 v1342 = C::value_type(ctx, v30);
                                                        let v1373 = C::value_type(ctx, v27);
                                                        if v1342 == v1373 {
                                                            let v1376 = constructor_bor(ctx, v1342, v30, v27);
                                                            let v1377 = constructor_uextend(ctx, v2.0, v1376);
                                                            // Rule at src/opts/extends.isle line 72.
                                                            returns.extend(Some(v1377));
                                                            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 v97,
                                                    args: ref v98,
                                                } = &v19.1 {
                                                    match v97 {
                                                        &Opcode::Band => {
                                                            if v2.0 == v19.0 {
                                                                let v99 = C::unpack_value_array_2(ctx, v98);
                                                                let mut v109 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                                let mut v109 = v109.into_context_iter();
                                                                while let Some(v110) = v109.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v127,
                                                                        imm: v128,
                                                                    } = &v110.1 {
                                                                        if let &Opcode::Iconst = v127 {
                                                                            let v352 = C::ty_mask(ctx, v2.0);
                                                                            let v16 = C::u64_from_imm64(ctx, v15);
                                                                            let v353 = C::u64_and(ctx, v352, v16);
                                                                            let v351 = C::u64_from_imm64(ctx, v128);
                                                                            let v354 = C::u64_not(ctx, v351);
                                                                            let v355 = C::u64_and(ctx, v352, v354);
                                                                            let v356 = C::u64_eq(ctx, v353, v355);
                                                                            if v356 == true {
                                                                                if v2.0 == v110.0 {
                                                                                    let v349 = constructor_bor(ctx, v2.0, v99.0, v7.1);
                                                                                    // Rule at src/opts/bitops.isle line 64.
                                                                                    returns.extend(Some(v349));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &Opcode::Bor => {
                                                            if v2.0 == v19.0 {
                                                                let v99 = C::unpack_value_array_2(ctx, v98);
                                                                let mut v109 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                                let mut v109 = v109.into_context_iter();
                                                                while let Some(v110) = v109.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v127,
                                                                        imm: v128,
                                                                    } = &v110.1 {
                                                                        if let &Opcode::Iconst = v127 {
                                                                            if v2.0 == v110.0 {
                                                                                let v1051 = constructor_bor(ctx, v2.0, v99.1, v7.1);
                                                                                let v1052 = constructor_bor(ctx, v2.0, v99.0, v1051);
                                                                                // Rule at src/opts/cprop.isle line 216.
                                                                                returns.extend(Some(v1052));
                                                                                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 v334 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v335) = v334 {
                                            if v11.0 == v335 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                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 v961 = C::imm64_or(ctx, v335, v23, v15);
                                                                let v962 = constructor_iconst(ctx, v335, v961);
                                                                let v963 = C::subsume(ctx, v962);
                                                                // Rule at src/opts/cprop.isle line 55.
                                                                returns.extend(Some(v963));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        let v1605 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 17.
                                        returns.extend(Some(v1605));
                                        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 v97,
                                    args: ref v98,
                                } => {
                                    match v97 {
                                        &Opcode::Band => {
                                            if v2.0 == v19.0 {
                                                let v99 = C::unpack_value_array_2(ctx, v98);
                                                let mut v102 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v99.0, &mut v102);
                                                let mut v102 = v102.into_context_iter();
                                                while let Some(v103) = v102.next(ctx) {
                                                    match &v103.1 {
                                                        &InstructionData::Binary {
                                                            opcode: ref v284,
                                                            args: ref v285,
                                                        } => {
                                                            match v284 {
                                                                &Opcode::Bor => {
                                                                    if v2.0 == v103.0 {
                                                                        let v286 = C::unpack_value_array_2(ctx, v285);
                                                                        if v7.1 == v286.0 {
                                                                            let v834 = constructor_band(ctx, v2.0, v99.1, v286.1);
                                                                            let v835 = constructor_bor(ctx, v2.0, v834, v286.0);
                                                                            // Rule at src/opts/bitops.isle line 498.
                                                                            returns.extend(Some(v835));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.1 == v286.1 {
                                                                            let v842 = constructor_band(ctx, v2.0, v99.1, v286.0);
                                                                            let v843 = constructor_bor(ctx, v2.0, v842, v286.1);
                                                                            // Rule at src/opts/bitops.isle line 502.
                                                                            returns.extend(Some(v843));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Bxor => {
                                                                    if v2.0 == v103.0 {
                                                                        let v286 = C::unpack_value_array_2(ctx, v285);
                                                                        if v7.1 == v286.0 {
                                                                            let v804 = constructor_band(ctx, v2.0, v286.1, v99.1);
                                                                            let v805 = constructor_bor(ctx, v2.0, v804, v286.0);
                                                                            // Rule at src/opts/bitops.isle line 438.
                                                                            returns.extend(Some(v805));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.1 == v286.1 {
                                                                            let v796 = constructor_band(ctx, v2.0, v286.0, v99.1);
                                                                            let v797 = constructor_bor(ctx, v2.0, v796, v286.1);
                                                                            // Rule at src/opts/bitops.isle line 434.
                                                                            returns.extend(Some(v797));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v106,
                                                            arg: v107,
                                                        } => {
                                                            if let &Opcode::Bnot = v106 {
                                                                if v7.1 == v107 {
                                                                    if v2.0 == v103.0 {
                                                                        let v866 = constructor_bor(ctx, v2.0, v107, v99.1);
                                                                        // Rule at src/opts/bitops.isle line 533.
                                                                        returns.extend(Some(v866));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let mut v109 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                let mut v109 = v109.into_context_iter();
                                                while let Some(v110) = v109.next(ctx) {
                                                    match &v110.1 {
                                                        &InstructionData::Binary {
                                                            opcode: ref v268,
                                                            args: ref v269,
                                                        } => {
                                                            match v268 {
                                                                &Opcode::Bor => {
                                                                    if v2.0 == v110.0 {
                                                                        let v270 = C::unpack_value_array_2(ctx, v269);
                                                                        if v7.1 == v270.0 {
                                                                            let v830 = constructor_band(ctx, v2.0, v99.0, v270.1);
                                                                            let v831 = constructor_bor(ctx, v2.0, v830, v270.0);
                                                                            // Rule at src/opts/bitops.isle line 496.
                                                                            returns.extend(Some(v831));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.1 == v270.1 {
                                                                            let v838 = constructor_band(ctx, v2.0, v99.0, v270.0);
                                                                            let v839 = constructor_bor(ctx, v2.0, v838, v270.1);
                                                                            // Rule at src/opts/bitops.isle line 500.
                                                                            returns.extend(Some(v839));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Bxor => {
                                                                    if v2.0 == v110.0 {
                                                                        let v270 = C::unpack_value_array_2(ctx, v269);
                                                                        if v7.1 == v270.0 {
                                                                            let v808 = constructor_band(ctx, v2.0, v270.1, v99.0);
                                                                            let v809 = constructor_bor(ctx, v2.0, v808, v270.0);
                                                                            // Rule at src/opts/bitops.isle line 440.
                                                                            returns.extend(Some(v809));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.1 == v270.1 {
                                                                            let v800 = constructor_band(ctx, v2.0, v270.0, v99.0);
                                                                            let v801 = constructor_bor(ctx, v2.0, v800, v270.1);
                                                                            // Rule at src/opts/bitops.isle line 436.
                                                                            returns.extend(Some(v801));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v113,
                                                            arg: v114,
                                                        } => {
                                                            if let &Opcode::Bnot = v113 {
                                                                if v7.1 == v114 {
                                                                    if v2.0 == v110.0 {
                                                                        let v867 = constructor_bor(ctx, v2.0, v114, v99.0);
                                                                        // Rule at src/opts/bitops.isle line 535.
                                                                        returns.extend(Some(v867));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                if v7.1 == v99.0 {
                                                    // Rule at src/opts/bitops.isle line 212.
                                                    returns.extend(Some(v99.0));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        &Opcode::Bor => {
                                            if v2.0 == v19.0 {
                                                let v99 = C::unpack_value_array_2(ctx, v98);
                                                if v7.1 == v99.0 {
                                                    let v240 = constructor_bor(ctx, v2.0, v99.0, v99.1);
                                                    // Rule at src/opts/bitops.isle line 187.
                                                    returns.extend(Some(v240));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.1 == v99.1 {
                                                    let v240 = constructor_bor(ctx, v2.0, v99.0, v99.1);
                                                    // Rule at src/opts/bitops.isle line 188.
                                                    returns.extend(Some(v240));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        &Opcode::Bxor => {
                                            if v2.0 == v19.0 {
                                                let v99 = C::unpack_value_array_2(ctx, v98);
                                                let mut v102 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v99.0, &mut v102);
                                                let mut v102 = v102.into_context_iter();
                                                while let Some(v103) = v102.next(ctx) {
                                                    match &v103.1 {
                                                        &InstructionData::Binary {
                                                            opcode: ref v284,
                                                            args: ref v285,
                                                        } => {
                                                            match v284 {
                                                                &Opcode::Band => {
                                                                    if v2.0 == v103.0 {
                                                                        let v286 = C::unpack_value_array_2(ctx, v285);
                                                                        if v7.1 == v286.0 {
                                                                            let v858 = constructor_bor(ctx, v2.0, v99.1, v286.0);
                                                                            // Rule at src/opts/bitops.isle line 518.
                                                                            returns.extend(Some(v858));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.1 == v286.1 {
                                                                            let v850 = constructor_bor(ctx, v2.0, v99.1, v286.1);
                                                                            // Rule at src/opts/bitops.isle line 522.
                                                                            returns.extend(Some(v850));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Bxor => {
                                                                    if v2.0 == v103.0 {
                                                                        let v286 = C::unpack_value_array_2(ctx, v285);
                                                                        if v7.1 == v286.0 {
                                                                            let v708 = constructor_bxor(ctx, v2.0, v286.1, v99.1);
                                                                            let v709 = constructor_bor(ctx, v2.0, v708, v286.0);
                                                                            // Rule at src/opts/bitops.isle line 293.
                                                                            returns.extend(Some(v709));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.1 == v286.1 {
                                                                            let v716 = constructor_bxor(ctx, v2.0, v286.0, v99.1);
                                                                            let v717 = constructor_bor(ctx, v2.0, v716, v286.1);
                                                                            // Rule at src/opts/bitops.isle line 297.
                                                                            returns.extend(Some(v717));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v106,
                                                            arg: v107,
                                                        } => {
                                                            if let &Opcode::Bnot = v106 {
                                                                if v7.1 == v107 {
                                                                    if v2.0 == v103.0 {
                                                                        let v663 = constructor_bnot(ctx, v2.0, v99.1);
                                                                        let v885 = constructor_bor(ctx, v2.0, v107, v663);
                                                                        // Rule at src/opts/bitops.isle line 597.
                                                                        returns.extend(Some(v885));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let mut v109 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                let mut v109 = v109.into_context_iter();
                                                while let Some(v110) = v109.next(ctx) {
                                                    match &v110.1 {
                                                        &InstructionData::Binary {
                                                            opcode: ref v268,
                                                            args: ref v269,
                                                        } => {
                                                            match v268 {
                                                                &Opcode::Band => {
                                                                    if v2.0 == v110.0 {
                                                                        let v270 = C::unpack_value_array_2(ctx, v269);
                                                                        if v7.1 == v270.0 {
                                                                            let v854 = constructor_bor(ctx, v2.0, v99.0, v270.0);
                                                                            // Rule at src/opts/bitops.isle line 516.
                                                                            returns.extend(Some(v854));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.1 == v270.1 {
                                                                            let v846 = constructor_bor(ctx, v2.0, v99.0, v270.1);
                                                                            // Rule at src/opts/bitops.isle line 520.
                                                                            returns.extend(Some(v846));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Bxor => {
                                                                    if v2.0 == v110.0 {
                                                                        let v270 = C::unpack_value_array_2(ctx, v269);
                                                                        if v7.1 == v270.0 {
                                                                            let v712 = constructor_bxor(ctx, v2.0, v270.1, v99.0);
                                                                            let v713 = constructor_bor(ctx, v2.0, v712, v270.0);
                                                                            // Rule at src/opts/bitops.isle line 295.
                                                                            returns.extend(Some(v713));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.1 == v270.1 {
                                                                            let v720 = constructor_bxor(ctx, v2.0, v270.0, v99.0);
                                                                            let v721 = constructor_bor(ctx, v2.0, v720, v270.1);
                                                                            // Rule at src/opts/bitops.isle line 299.
                                                                            returns.extend(Some(v721));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v113,
                                                            arg: v114,
                                                        } => {
                                                            if let &Opcode::Bnot = v113 {
                                                                if v7.1 == v114 {
                                                                    if v2.0 == v110.0 {
                                                                        let v633 = constructor_bnot(ctx, v2.0, v99.0);
                                                                        let v887 = constructor_bor(ctx, v2.0, v114, v633);
                                                                        // Rule at src/opts/bitops.isle line 599.
                                                                        returns.extend(Some(v887));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                if v7.1 == v99.0 {
                                                    let v240 = constructor_bor(ctx, v2.0, v99.0, v99.1);
                                                    // Rule at src/opts/bitops.isle line 405.
                                                    returns.extend(Some(v240));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.1 == v99.1 {
                                                    let v241 = constructor_bor(ctx, v2.0, v99.1, v99.0);
                                                    // Rule at src/opts/bitops.isle line 407.
                                                    returns.extend(Some(v241));
                                                    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 v649 = C::inst_data_value_etor_returns::default();
                                            C::inst_data_value_etor(ctx, v30, &mut v649);
                                            let mut v649 = v649.into_context_iter();
                                            while let Some(v650) = v649.next(ctx) {
                                                if let &InstructionData::Binary {
                                                    opcode: ref v653,
                                                    args: ref v654,
                                                } = &v650.1 {
                                                    match v653 {
                                                        &Opcode::Bor => {
                                                            if v2.0 == v650.0 {
                                                                let v655 = C::unpack_value_array_2(ctx, v654);
                                                                if v7.1 == v655.0 {
                                                                    let v738 = constructor_bnot(ctx, v2.0, v655.1);
                                                                    let v739 = constructor_bor(ctx, v2.0, v655.0, v738);
                                                                    // Rule at src/opts/bitops.isle line 316.
                                                                    returns.extend(Some(v739));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v7.1 == v655.1 {
                                                                    let v734 = constructor_bnot(ctx, v2.0, v655.0);
                                                                    let v735 = constructor_bor(ctx, v2.0, v655.1, v734);
                                                                    // Rule at src/opts/bitops.isle line 314.
                                                                    returns.extend(Some(v735));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                        &Opcode::Bxor => {
                                                            if v2.0 == v650.0 {
                                                                let v655 = C::unpack_value_array_2(ctx, v654);
                                                                if v7.1 == v655.0 {
                                                                    let v738 = constructor_bnot(ctx, v2.0, v655.1);
                                                                    let v739 = constructor_bor(ctx, v2.0, v655.0, v738);
                                                                    // Rule at src/opts/bitops.isle line 591.
                                                                    returns.extend(Some(v739));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v7.1 == v655.1 {
                                                                    let v734 = constructor_bnot(ctx, v2.0, v655.0);
                                                                    let v735 = constructor_bor(ctx, v2.0, v655.1, v734);
                                                                    // Rule at src/opts/bitops.isle line 593.
                                                                    returns.extend(Some(v735));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                            }
                                        }
                                        if v7.1 == v30 {
                                            let v343 = C::ty_int_vec128(ctx, v2.0);
                                            if let Some(v344) = v343 {
                                                if v19.0 == v344 {
                                                    let v345 = constructor_iconst_s(ctx, v344, -1_i64);
                                                    let v346 = C::subsume(ctx, v345);
                                                    // Rule at src/opts/bitops.isle line 25.
                                                    returns.extend(Some(v346));
                                                    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 v1023 = constructor_bor(ctx, v2.0, v7.1, v7.0);
                                            // Rule at src/opts/cprop.isle line 158.
                                            returns.extend(Some(v1023));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        let v1605 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 15.
                                        returns.extend(Some(v1605));
                                        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 v133,
                                    args: ref v134,
                                } => {
                                    match v133 {
                                        &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 v97,
                                                            args: ref v98,
                                                        } => {
                                                            match v97 {
                                                                &Opcode::Band => {
                                                                    if v2.0 == v19.0 {
                                                                        let v99 = C::unpack_value_array_2(ctx, v98);
                                                                        let v135 = C::unpack_value_array_2(ctx, v134);
                                                                        if v99.0 == v135.0 {
                                                                            let v637 = constructor_bxor(ctx, v2.0, v99.1, v135.1);
                                                                            let v638 = constructor_band(ctx, v2.0, v99.0, v637);
                                                                            // Rule at src/opts/bitops.isle line 224.
                                                                            returns.extend(Some(v638));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Bor => {
                                                                    if v2.0 == v19.0 {
                                                                        let v99 = C::unpack_value_array_2(ctx, v98);
                                                                        let v135 = C::unpack_value_array_2(ctx, v134);
                                                                        if v99.0 == v135.0 {
                                                                            if v99.1 == v135.1 {
                                                                                let v238 = constructor_bxor(ctx, v2.0, v99.0, v99.1);
                                                                                // Rule at src/opts/bitops.isle line 184.
                                                                                returns.extend(Some(v238));
                                                                                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 v135 = C::unpack_value_array_2(ctx, v134);
                                                                    if v30 == v135.0 {
                                                                        let mut v258 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v135.1, &mut v258);
                                                                        let mut v258 = v258.into_context_iter();
                                                                        while let Some(v259) = v258.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v627,
                                                                                arg: v628,
                                                                            } = &v259.1 {
                                                                                if let &Opcode::Bnot = v627 {
                                                                                    if v2.0 == v259.0 {
                                                                                        let v877 = constructor_band(ctx, v2.0, v30, v628);
                                                                                        let v878 = constructor_bnot(ctx, v2.0, v877);
                                                                                        // Rule at src/opts/bitops.isle line 569.
                                                                                        returns.extend(Some(v878));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    if v30 == v135.1 {
                                                                        let mut v274 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v135.0, &mut v274);
                                                                        let mut v274 = v274.into_context_iter();
                                                                        while let Some(v275) = v274.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v630,
                                                                                arg: v631,
                                                                            } = &v275.1 {
                                                                                if let &Opcode::Bnot = v630 {
                                                                                    if v2.0 == v275.0 {
                                                                                        let v880 = constructor_band(ctx, v2.0, v30, v631);
                                                                                        let v881 = constructor_bnot(ctx, v2.0, v880);
                                                                                        // Rule at src/opts/bitops.isle line 571.
                                                                                        returns.extend(Some(v881));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let v135 = C::unpack_value_array_2(ctx, v134);
                                                let mut v258 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v135.1, &mut v258);
                                                let mut v258 = v258.into_context_iter();
                                                while let Some(v259) = v258.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v627,
                                                        arg: v628,
                                                    } = &v259.1 {
                                                        if let &Opcode::Bnot = v627 {
                                                            if v2.0 == v259.0 {
                                                                if v7.0 == v628 {
                                                                    let v785 = constructor_bor(ctx, v2.0, v7.0, v135.0);
                                                                    // Rule at src/opts/bitops.isle line 577.
                                                                    returns.extend(Some(v785));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                let v921 = constructor_band(ctx, v2.0, v628, v135.0);
                                                                let v922 = constructor_bxor(ctx, v2.0, v7.0, v135.0);
                                                                let v923 = constructor_bxor(ctx, v2.0, v921, v922);
                                                                // Rule at src/opts/bitops.isle line 645.
                                                                returns.extend(Some(v923));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                                let mut v274 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v135.0, &mut v274);
                                                let mut v274 = v274.into_context_iter();
                                                while let Some(v275) = v274.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v630,
                                                        arg: v631,
                                                    } = &v275.1 {
                                                        if let &Opcode::Bnot = v630 {
                                                            if v2.0 == v275.0 {
                                                                if v7.0 == v631 {
                                                                    let v622 = constructor_bor(ctx, v2.0, v7.0, v135.1);
                                                                    // Rule at src/opts/bitops.isle line 575.
                                                                    returns.extend(Some(v622));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                let v916 = constructor_band(ctx, v2.0, v631, v135.1);
                                                                let v917 = constructor_bxor(ctx, v2.0, v7.0, v135.1);
                                                                let v918 = constructor_bxor(ctx, v2.0, v916, v917);
                                                                // Rule at src/opts/bitops.isle line 643.
                                                                returns.extend(Some(v918));
                                                                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 v97,
                                                            args: ref v98,
                                                        } => {
                                                            match v97 {
                                                                &Opcode::Bor => {
                                                                    if v2.0 == v19.0 {
                                                                        let v99 = C::unpack_value_array_2(ctx, v98);
                                                                        let v135 = C::unpack_value_array_2(ctx, v134);
                                                                        if v99.0 == v135.0 {
                                                                            let mut v109 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                                            let mut v109 = v109.into_context_iter();
                                                                            while let Some(v110) = v109.next(ctx) {
                                                                                if let &InstructionData::Unary {
                                                                                    opcode: ref v113,
                                                                                    arg: v114,
                                                                                } = &v110.1 {
                                                                                    if let &Opcode::Bnot = v113 {
                                                                                        if v2.0 == v110.0 {
                                                                                            if v114 == v135.1 {
                                                                                                let v633 = constructor_bnot(ctx, v2.0, v99.0);
                                                                                                // Rule at src/opts/bitops.isle line 276.
                                                                                                returns.extend(Some(v633));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            let mut v258 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v135.1, &mut v258);
                                                                            let mut v258 = v258.into_context_iter();
                                                                            while let Some(v259) = v258.next(ctx) {
                                                                                if let &InstructionData::Unary {
                                                                                    opcode: ref v627,
                                                                                    arg: v628,
                                                                                } = &v259.1 {
                                                                                    if let &Opcode::Bnot = v627 {
                                                                                        if v99.1 == v628 {
                                                                                            if v2.0 == v259.0 {
                                                                                                let v633 = constructor_bnot(ctx, v2.0, v99.0);
                                                                                                // Rule at src/opts/bitops.isle line 275.
                                                                                                returns.extend(Some(v633));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        if v99.0 == v135.1 {
                                                                            let mut v109 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                                            let mut v109 = v109.into_context_iter();
                                                                            while let Some(v110) = v109.next(ctx) {
                                                                                if let &InstructionData::Unary {
                                                                                    opcode: ref v113,
                                                                                    arg: v114,
                                                                                } = &v110.1 {
                                                                                    if let &Opcode::Bnot = v113 {
                                                                                        if v114 == v135.0 {
                                                                                            if v2.0 == v110.0 {
                                                                                                let v633 = constructor_bnot(ctx, v2.0, v99.0);
                                                                                                // Rule at src/opts/bitops.isle line 280.
                                                                                                returns.extend(Some(v633));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            let mut v274 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v135.0, &mut v274);
                                                                            let mut v274 = v274.into_context_iter();
                                                                            while let Some(v275) = v274.next(ctx) {
                                                                                if let &InstructionData::Unary {
                                                                                    opcode: ref v630,
                                                                                    arg: v631,
                                                                                } = &v275.1 {
                                                                                    if let &Opcode::Bnot = v630 {
                                                                                        if v99.1 == v631 {
                                                                                            if v2.0 == v275.0 {
                                                                                                let v633 = constructor_bnot(ctx, v2.0, v99.0);
                                                                                                // Rule at src/opts/bitops.isle line 277.
                                                                                                returns.extend(Some(v633));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        if v99.1 == v135.0 {
                                                                            let mut v102 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v99.0, &mut v102);
                                                                            let mut v102 = v102.into_context_iter();
                                                                            while let Some(v103) = v102.next(ctx) {
                                                                                if let &InstructionData::Unary {
                                                                                    opcode: ref v106,
                                                                                    arg: v107,
                                                                                } = &v103.1 {
                                                                                    if let &Opcode::Bnot = v106 {
                                                                                        if v107 == v135.1 {
                                                                                            if v2.0 == v103.0 {
                                                                                                let v663 = constructor_bnot(ctx, v2.0, v99.1);
                                                                                                // Rule at src/opts/bitops.isle line 278.
                                                                                                returns.extend(Some(v663));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            let mut v258 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v135.1, &mut v258);
                                                                            let mut v258 = v258.into_context_iter();
                                                                            while let Some(v259) = v258.next(ctx) {
                                                                                if let &InstructionData::Unary {
                                                                                    opcode: ref v627,
                                                                                    arg: v628,
                                                                                } = &v259.1 {
                                                                                    if let &Opcode::Bnot = v627 {
                                                                                        if v99.0 == v628 {
                                                                                            if v2.0 == v259.0 {
                                                                                                let v663 = constructor_bnot(ctx, v2.0, v99.1);
                                                                                                // Rule at src/opts/bitops.isle line 279.
                                                                                                returns.extend(Some(v663));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        if v99.1 == v135.1 {
                                                                            let mut v102 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v99.0, &mut v102);
                                                                            let mut v102 = v102.into_context_iter();
                                                                            while let Some(v103) = v102.next(ctx) {
                                                                                if let &InstructionData::Unary {
                                                                                    opcode: ref v106,
                                                                                    arg: v107,
                                                                                } = &v103.1 {
                                                                                    if let &Opcode::Bnot = v106 {
                                                                                        if v107 == v135.0 {
                                                                                            if v2.0 == v103.0 {
                                                                                                let v663 = constructor_bnot(ctx, v2.0, v99.1);
                                                                                                // Rule at src/opts/bitops.isle line 282.
                                                                                                returns.extend(Some(v663));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            let mut v274 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v135.0, &mut v274);
                                                                            let mut v274 = v274.into_context_iter();
                                                                            while let Some(v275) = v274.next(ctx) {
                                                                                if let &InstructionData::Unary {
                                                                                    opcode: ref v630,
                                                                                    arg: v631,
                                                                                } = &v275.1 {
                                                                                    if let &Opcode::Bnot = v630 {
                                                                                        if v99.0 == v631 {
                                                                                            if v2.0 == v275.0 {
                                                                                                let v663 = constructor_bnot(ctx, v2.0, v99.1);
                                                                                                // Rule at src/opts/bitops.isle line 281.
                                                                                                returns.extend(Some(v663));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Bxor => {
                                                                    if v2.0 == v19.0 {
                                                                        let v99 = C::unpack_value_array_2(ctx, v98);
                                                                        let v135 = C::unpack_value_array_2(ctx, v134);
                                                                        if v99.0 == v135.0 {
                                                                            if v99.1 == v135.1 {
                                                                                let v242 = constructor_band(ctx, v2.0, v99.1, v99.0);
                                                                                // Rule at src/opts/bitops.isle line 425.
                                                                                returns.extend(Some(v242));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                let v138 = constructor_band(ctx, v2.0, v99.0, v99.1);
                                                                                // Rule at src/opts/bitops.isle line 431.
                                                                                returns.extend(Some(v138));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                            let mut v258 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v135.1, &mut v258);
                                                                            let mut v258 = v258.into_context_iter();
                                                                            while let Some(v259) = v258.next(ctx) {
                                                                                if let &InstructionData::Unary {
                                                                                    opcode: ref v627,
                                                                                    arg: v628,
                                                                                } = &v259.1 {
                                                                                    if let &Opcode::Bnot = v627 {
                                                                                        if v99.1 == v628 {
                                                                                            if v2.0 == v259.0 {
                                                                                                let v633 = constructor_bnot(ctx, v2.0, v99.0);
                                                                                                let v634 = constructor_bor(ctx, v2.0, v99.1, v633);
                                                                                                // Rule at src/opts/bitops.isle line 688.
                                                                                                returns.extend(Some(v634));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        if v99.0 == v135.1 {
                                                                            if v99.1 == v135.0 {
                                                                                let v138 = constructor_band(ctx, v2.0, v99.0, v99.1);
                                                                                // Rule at src/opts/bitops.isle line 427.
                                                                                returns.extend(Some(v138));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                let v242 = constructor_band(ctx, v2.0, v99.1, v99.0);
                                                                                // Rule at src/opts/bitops.isle line 429.
                                                                                returns.extend(Some(v242));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                            let mut v274 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v135.0, &mut v274);
                                                                            let mut v274 = v274.into_context_iter();
                                                                            while let Some(v275) = v274.next(ctx) {
                                                                                if let &InstructionData::Unary {
                                                                                    opcode: ref v630,
                                                                                    arg: v631,
                                                                                } = &v275.1 {
                                                                                    if let &Opcode::Bnot = v630 {
                                                                                        if v99.1 == v631 {
                                                                                            if v2.0 == v275.0 {
                                                                                                let v633 = constructor_bnot(ctx, v2.0, v99.0);
                                                                                                let v634 = constructor_bor(ctx, v2.0, v99.1, v633);
                                                                                                // Rule at src/opts/bitops.isle line 684.
                                                                                                returns.extend(Some(v634));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        if v99.1 == v135.0 {
                                                                            let mut v258 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v135.1, &mut v258);
                                                                            let mut v258 = v258.into_context_iter();
                                                                            while let Some(v259) = v258.next(ctx) {
                                                                                if let &InstructionData::Unary {
                                                                                    opcode: ref v627,
                                                                                    arg: v628,
                                                                                } = &v259.1 {
                                                                                    if let &Opcode::Bnot = v627 {
                                                                                        if v99.0 == v628 {
                                                                                            if v2.0 == v259.0 {
                                                                                                let v663 = constructor_bnot(ctx, v2.0, v99.1);
                                                                                                let v746 = constructor_bor(ctx, v2.0, v99.0, v663);
                                                                                                // Rule at src/opts/bitops.isle line 686.
                                                                                                returns.extend(Some(v746));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        if v99.1 == v135.1 {
                                                                            let mut v274 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v135.0, &mut v274);
                                                                            let mut v274 = v274.into_context_iter();
                                                                            while let Some(v275) = v274.next(ctx) {
                                                                                if let &InstructionData::Unary {
                                                                                    opcode: ref v630,
                                                                                    arg: v631,
                                                                                } = &v275.1 {
                                                                                    if let &Opcode::Bnot = v630 {
                                                                                        if v99.0 == v631 {
                                                                                            if v2.0 == v275.0 {
                                                                                                let v663 = constructor_bnot(ctx, v2.0, v99.1);
                                                                                                let v746 = constructor_bor(ctx, v2.0, v99.0, v663);
                                                                                                // Rule at src/opts/bitops.isle line 682.
                                                                                                returns.extend(Some(v746));
                                                                                                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 v135 = C::unpack_value_array_2(ctx, v134);
                                                                    if v30 == v135.0 {
                                                                        let v744 = constructor_bnot(ctx, v2.0, v135.1);
                                                                        let v745 = constructor_bor(ctx, v2.0, v30, v744);
                                                                        // Rule at src/opts/bitops.isle line 325.
                                                                        returns.extend(Some(v745));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v30 == v135.1 {
                                                                        let v747 = constructor_bnot(ctx, v2.0, v135.0);
                                                                        let v748 = constructor_bor(ctx, v2.0, v30, v747);
                                                                        // Rule at src/opts/bitops.isle line 327.
                                                                        returns.extend(Some(v748));
                                                                        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 v97,
                                                        args: ref v98,
                                                    } = &v19.1 {
                                                        match v97 {
                                                            &Opcode::Band => {
                                                                if v2.0 == v19.0 {
                                                                    let v99 = C::unpack_value_array_2(ctx, v98);
                                                                    let v135 = C::unpack_value_array_2(ctx, v134);
                                                                    if v99.0 == v135.0 {
                                                                        if v99.1 == v135.1 {
                                                                            let v240 = constructor_bor(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/bitops.isle line 38.
                                                                            returns.extend(Some(v240));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Bor => {
                                                                if v2.0 == v19.0 {
                                                                    let v99 = C::unpack_value_array_2(ctx, v98);
                                                                    let v135 = C::unpack_value_array_2(ctx, v134);
                                                                    if v99.0 == v135.0 {
                                                                        if v99.1 == v135.1 {
                                                                            let v242 = constructor_band(ctx, v2.0, v99.1, v99.0);
                                                                            // Rule at src/opts/bitops.isle line 424.
                                                                            returns.extend(Some(v242));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            let v138 = constructor_band(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/bitops.isle line 430.
                                                                            returns.extend(Some(v138));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        let mut v109 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                                        let mut v109 = v109.into_context_iter();
                                                                        while let Some(v110) = v109.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v113,
                                                                                arg: v114,
                                                                            } = &v110.1 {
                                                                                if let &Opcode::Bnot = v113 {
                                                                                    if v114 == v135.1 {
                                                                                        if v2.0 == v110.0 {
                                                                                            let v633 = constructor_bnot(ctx, v2.0, v99.0);
                                                                                            let v887 = constructor_bor(ctx, v2.0, v114, v633);
                                                                                            // Rule at src/opts/bitops.isle line 687.
                                                                                            returns.extend(Some(v887));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    if v99.0 == v135.1 {
                                                                        if v99.1 == v135.0 {
                                                                            let v242 = constructor_band(ctx, v2.0, v99.1, v99.0);
                                                                            // Rule at src/opts/bitops.isle line 426.
                                                                            returns.extend(Some(v242));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            let v138 = constructor_band(ctx, v2.0, v99.0, v99.1);
                                                                            // Rule at src/opts/bitops.isle line 428.
                                                                            returns.extend(Some(v138));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        let mut v109 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                                        let mut v109 = v109.into_context_iter();
                                                                        while let Some(v110) = v109.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v113,
                                                                                arg: v114,
                                                                            } = &v110.1 {
                                                                                if let &Opcode::Bnot = v113 {
                                                                                    if v114 == v135.0 {
                                                                                        if v2.0 == v110.0 {
                                                                                            let v633 = constructor_bnot(ctx, v2.0, v99.0);
                                                                                            let v887 = constructor_bor(ctx, v2.0, v114, v633);
                                                                                            // Rule at src/opts/bitops.isle line 685.
                                                                                            returns.extend(Some(v887));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    let mut v102 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v99.0, &mut v102);
                                                                    let mut v102 = v102.into_context_iter();
                                                                    while let Some(v103) = v102.next(ctx) {
                                                                        if let &InstructionData::Unary {
                                                                            opcode: ref v106,
                                                                            arg: v107,
                                                                        } = &v103.1 {
                                                                            if let &Opcode::Bnot = v106 {
                                                                                if v2.0 == v103.0 {
                                                                                    if v107 == v135.0 {
                                                                                        if v99.1 == v135.1 {
                                                                                            let v663 = constructor_bnot(ctx, v2.0, v99.1);
                                                                                            let v885 = constructor_bor(ctx, v2.0, v107, v663);
                                                                                            // Rule at src/opts/bitops.isle line 681.
                                                                                            returns.extend(Some(v885));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                    if v107 == v135.1 {
                                                                                        if v99.1 == v135.0 {
                                                                                            let v663 = constructor_bnot(ctx, v2.0, v99.1);
                                                                                            let v885 = constructor_bor(ctx, v2.0, v107, v663);
                                                                                            // Rule at src/opts/bitops.isle line 683.
                                                                                            returns.extend(Some(v885));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Bxor => {
                                                                if v2.0 == v19.0 {
                                                                    let v99 = C::unpack_value_array_2(ctx, v98);
                                                                    let mut v109 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                                    let mut v109 = v109.into_context_iter();
                                                                    while let Some(v110) = v109.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v127,
                                                                            imm: v128,
                                                                        } = &v110.1 {
                                                                            if let &Opcode::Iconst = v127 {
                                                                                let v135 = C::unpack_value_array_2(ctx, v134);
                                                                                let mut v258 = C::inst_data_value_etor_returns::default();
                                                                                C::inst_data_value_etor(ctx, v135.1, &mut v258);
                                                                                let mut v258 = v258.into_context_iter();
                                                                                while let Some(v259) = v258.next(ctx) {
                                                                                    if let &InstructionData::UnaryImm {
                                                                                        opcode: ref v1124,
                                                                                        imm: v1125,
                                                                                    } = &v259.1 {
                                                                                        if let &Opcode::Iconst = v1124 {
                                                                                            let v1135 = constructor_bxor(ctx, v2.0, v99.0, v135.0);
                                                                                            let v1136 = constructor_bxor(ctx, v2.0, v99.1, v135.1);
                                                                                            let v1137 = constructor_bxor(ctx, v2.0, v1135, v1136);
                                                                                            // Rule at src/opts/cprop.isle line 329.
                                                                                            returns.extend(Some(v1137));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                    }
                                                }
                                                let v135 = C::unpack_value_array_2(ctx, v134);
                                                if v7.0 == v135.1 {
                                                    // Rule at src/opts/bitops.isle line 217.
                                                    returns.extend(Some(v135.0));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    // Rule at src/opts/bitops.isle line 493.
                                                    returns.extend(Some(v135.0));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.0 == v135.0 {
                                                    // Rule at src/opts/bitops.isle line 491.
                                                    returns.extend(Some(v135.1));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::IntCompare {
                                    opcode: ref v755,
                                    args: ref v756,
                                    cond: ref v757,
                                } => {
                                    if let &Opcode::Icmp = v755 {
                                        match v757 {
                                            &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 v749,
                                                            args: ref v750,
                                                            cond: ref v751,
                                                        } = &v19.1 {
                                                            if let &Opcode::Icmp = v749 {
                                                                match v751 {
                                                                    &IntCC::SignedGreaterThan => {
                                                                        if v2.0 == v19.0 {
                                                                            let v752 = C::unpack_value_array_2(ctx, v750);
                                                                            let v758 = C::unpack_value_array_2(ctx, v756);
                                                                            if v752.0 == v758.1 {
                                                                                if v752.1 == v758.0 {
                                                                                    let v761 = constructor_ne(ctx, v2.0, v752.0, v752.1);
                                                                                    // Rule at src/opts/icmp.isle line 309.
                                                                                    returns.extend(Some(v761));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedLessThan => {
                                                                        if v2.0 == v19.0 {
                                                                            let v752 = C::unpack_value_array_2(ctx, v750);
                                                                            let v758 = C::unpack_value_array_2(ctx, v756);
                                                                            if v752.0 == v758.0 {
                                                                                if v752.1 == v758.1 {
                                                                                    let v761 = constructor_ne(ctx, v2.0, v752.0, v752.1);
                                                                                    // Rule at src/opts/icmp.isle line 311.
                                                                                    returns.extend(Some(v761));
                                                                                    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 v749,
                                                            args: ref v750,
                                                            cond: ref v751,
                                                        } = &v19.1 {
                                                            if let &Opcode::Icmp = v749 {
                                                                match v751 {
                                                                    &IntCC::SignedGreaterThan => {
                                                                        if v2.0 == v19.0 {
                                                                            let v752 = C::unpack_value_array_2(ctx, v750);
                                                                            let v758 = C::unpack_value_array_2(ctx, v756);
                                                                            if v752.0 == v758.0 {
                                                                                if v752.1 == v758.1 {
                                                                                    let v761 = constructor_ne(ctx, v2.0, v752.0, v752.1);
                                                                                    // Rule at src/opts/icmp.isle line 310.
                                                                                    returns.extend(Some(v761));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedLessThan => {
                                                                        if v2.0 == v19.0 {
                                                                            let v752 = C::unpack_value_array_2(ctx, v750);
                                                                            let v758 = C::unpack_value_array_2(ctx, v756);
                                                                            if v752.0 == v758.1 {
                                                                                if v752.1 == v758.0 {
                                                                                    let v761 = constructor_ne(ctx, v2.0, v752.0, v752.1);
                                                                                    // Rule at src/opts/icmp.isle line 312.
                                                                                    returns.extend(Some(v761));
                                                                                    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 v749,
                                                            args: ref v750,
                                                            cond: ref v751,
                                                        } = &v19.1 {
                                                            if let &Opcode::Icmp = v749 {
                                                                match v751 {
                                                                    &IntCC::UnsignedGreaterThan => {
                                                                        if v2.0 == v19.0 {
                                                                            let v752 = C::unpack_value_array_2(ctx, v750);
                                                                            let v758 = C::unpack_value_array_2(ctx, v756);
                                                                            if v752.0 == v758.1 {
                                                                                if v752.1 == v758.0 {
                                                                                    let v761 = constructor_ne(ctx, v2.0, v752.0, v752.1);
                                                                                    // Rule at src/opts/icmp.isle line 313.
                                                                                    returns.extend(Some(v761));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        if v2.0 == v19.0 {
                                                                            let v752 = C::unpack_value_array_2(ctx, v750);
                                                                            let v758 = C::unpack_value_array_2(ctx, v756);
                                                                            if v752.0 == v758.0 {
                                                                                if v752.1 == v758.1 {
                                                                                    let v761 = constructor_ne(ctx, v2.0, v752.0, v752.1);
                                                                                    // Rule at src/opts/icmp.isle line 315.
                                                                                    returns.extend(Some(v761));
                                                                                    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 v749,
                                                            args: ref v750,
                                                            cond: ref v751,
                                                        } = &v19.1 {
                                                            if let &Opcode::Icmp = v749 {
                                                                match v751 {
                                                                    &IntCC::UnsignedGreaterThan => {
                                                                        if v2.0 == v19.0 {
                                                                            let v752 = C::unpack_value_array_2(ctx, v750);
                                                                            let v758 = C::unpack_value_array_2(ctx, v756);
                                                                            if v752.0 == v758.0 {
                                                                                if v752.1 == v758.1 {
                                                                                    let v761 = constructor_ne(ctx, v2.0, v752.0, v752.1);
                                                                                    // Rule at src/opts/icmp.isle line 314.
                                                                                    returns.extend(Some(v761));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        if v2.0 == v19.0 {
                                                                            let v752 = C::unpack_value_array_2(ctx, v750);
                                                                            let v758 = C::unpack_value_array_2(ctx, v756);
                                                                            if v752.0 == v758.1 {
                                                                                if v752.1 == v758.0 {
                                                                                    let v761 = constructor_ne(ctx, v2.0, v752.0, v752.1);
                                                                                    // Rule at src/opts/icmp.isle line 316.
                                                                                    returns.extend(Some(v761));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v26,
                                    arg: v27,
                                } => {
                                    match v26 {
                                        &Opcode::Splat => {
                                            let v1985 = C::ty_vector_not_float(ctx, v2.0);
                                            if let Some(v1986) = v1985 {
                                                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 v1849 = C::lane_type(ctx, v2.0);
                                                                    let v1991 = constructor_bxor(ctx, v1849, v30, v27);
                                                                    let v1992 = constructor_splat(ctx, v2.0, v1991);
                                                                    // Rule at src/opts/vector.isle line 22.
                                                                    returns.extend(Some(v1992));
                                                                    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 v97,
                                                        args: ref v98,
                                                    } = &v19.1 {
                                                        match v97 {
                                                            &Opcode::Band => {
                                                                if v2.0 == v19.0 {
                                                                    let v99 = C::unpack_value_array_2(ctx, v98);
                                                                    if v27 == v99.0 {
                                                                        let mut v109 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                                        let mut v109 = v109.into_context_iter();
                                                                        while let Some(v110) = v109.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v113,
                                                                                arg: v114,
                                                                            } = &v110.1 {
                                                                                if let &Opcode::Bnot = v113 {
                                                                                    if v2.0 == v110.0 {
                                                                                        let v625 = constructor_band(ctx, v2.0, v99.0, v114);
                                                                                        let v876 = constructor_bnot(ctx, v2.0, v625);
                                                                                        // Rule at src/opts/bitops.isle line 568.
                                                                                        returns.extend(Some(v876));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    if v27 == v99.1 {
                                                                        let mut v102 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v99.0, &mut v102);
                                                                        let mut v102 = v102.into_context_iter();
                                                                        while let Some(v103) = v102.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v106,
                                                                                arg: v107,
                                                                            } = &v103.1 {
                                                                                if let &Opcode::Bnot = v106 {
                                                                                    if v2.0 == v103.0 {
                                                                                        let v626 = constructor_band(ctx, v2.0, v99.1, v107);
                                                                                        let v879 = constructor_bnot(ctx, v2.0, v626);
                                                                                        // Rule at src/opts/bitops.isle line 570.
                                                                                        returns.extend(Some(v879));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Bor => {
                                                                if v2.0 == v19.0 {
                                                                    let v99 = C::unpack_value_array_2(ctx, v98);
                                                                    if v27 == v99.0 {
                                                                        let v663 = constructor_bnot(ctx, v2.0, v99.1);
                                                                        let v746 = constructor_bor(ctx, v2.0, v99.0, v663);
                                                                        // Rule at src/opts/bitops.isle line 326.
                                                                        returns.extend(Some(v746));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v27 == v99.1 {
                                                                        let v633 = constructor_bnot(ctx, v2.0, v99.0);
                                                                        let v634 = constructor_bor(ctx, v2.0, v99.1, v633);
                                                                        // Rule at src/opts/bitops.isle line 328.
                                                                        returns.extend(Some(v634));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                    }
                                                }
                                            }
                                            let v343 = C::ty_int_vec128(ctx, v2.0);
                                            if let Some(v344) = v343 {
                                                if v11.0 == v344 {
                                                    if v7.0 == v27 {
                                                        let v345 = constructor_iconst_s(ctx, v344, -1_i64);
                                                        let v346 = C::subsume(ctx, v345);
                                                        // Rule at src/opts/bitops.isle line 22.
                                                        returns.extend(Some(v346));
                                                        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 v1342 = C::value_type(ctx, v30);
                                                        let v1373 = C::value_type(ctx, v27);
                                                        if v1342 == v1373 {
                                                            let v1378 = constructor_bxor(ctx, v1342, v30, v27);
                                                            let v1379 = constructor_uextend(ctx, v2.0, v1378);
                                                            // Rule at src/opts/extends.isle line 74.
                                                            returns.extend(Some(v1379));
                                                            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 v97,
                                                    args: ref v98,
                                                } = &v19.1 {
                                                    if let &Opcode::Bxor = v97 {
                                                        if v2.0 == v19.0 {
                                                            let v99 = C::unpack_value_array_2(ctx, v98);
                                                            let mut v109 = C::inst_data_value_etor_returns::default();
                                                            C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                            let mut v109 = v109.into_context_iter();
                                                            while let Some(v110) = v109.next(ctx) {
                                                                if let &InstructionData::UnaryImm {
                                                                    opcode: ref v127,
                                                                    imm: v128,
                                                                } = &v110.1 {
                                                                    if let &Opcode::Iconst = v127 {
                                                                        if v2.0 == v110.0 {
                                                                            let v1055 = constructor_bxor(ctx, v2.0, v99.1, v7.1);
                                                                            let v1056 = constructor_bxor(ctx, v2.0, v99.0, v1055);
                                                                            // Rule at src/opts/cprop.isle line 222.
                                                                            returns.extend(Some(v1056));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        let v334 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v335) = v334 {
                                            if v11.0 == v335 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                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 v967 = C::imm64_xor(ctx, v335, v23, v15);
                                                                let v968 = constructor_iconst(ctx, v335, v967);
                                                                let v969 = C::subsume(ctx, v968);
                                                                // Rule at src/opts/cprop.isle line 67.
                                                                returns.extend(Some(v969));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        let v1605 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 21.
                                        returns.extend(Some(v1605));
                                        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 v97,
                                    args: ref v98,
                                } => {
                                    match v97 {
                                        &Opcode::Band => {
                                            if v2.0 == v19.0 {
                                                let v99 = C::unpack_value_array_2(ctx, v98);
                                                let mut v102 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v99.0, &mut v102);
                                                let mut v102 = v102.into_context_iter();
                                                while let Some(v103) = v102.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v106,
                                                        arg: v107,
                                                    } = &v103.1 {
                                                        if let &Opcode::Bnot = v106 {
                                                            if v2.0 == v103.0 {
                                                                if v7.1 == v107 {
                                                                    let v866 = constructor_bor(ctx, v2.0, v107, v99.1);
                                                                    // Rule at src/opts/bitops.isle line 574.
                                                                    returns.extend(Some(v866));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                let v863 = constructor_band(ctx, v2.0, v107, v99.1);
                                                                let v914 = constructor_bxor(ctx, v2.0, v7.1, v99.1);
                                                                let v915 = constructor_bxor(ctx, v2.0, v863, v914);
                                                                // Rule at src/opts/bitops.isle line 642.
                                                                returns.extend(Some(v915));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                                let mut v109 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                let mut v109 = v109.into_context_iter();
                                                while let Some(v110) = v109.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v113,
                                                        arg: v114,
                                                    } = &v110.1 {
                                                        if let &Opcode::Bnot = v113 {
                                                            if v2.0 == v110.0 {
                                                                if v7.1 == v114 {
                                                                    let v867 = constructor_bor(ctx, v2.0, v114, v99.0);
                                                                    // Rule at src/opts/bitops.isle line 576.
                                                                    returns.extend(Some(v867));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                let v865 = constructor_band(ctx, v2.0, v114, v99.0);
                                                                let v919 = constructor_bxor(ctx, v2.0, v7.1, v99.0);
                                                                let v920 = constructor_bxor(ctx, v2.0, v865, v919);
                                                                // Rule at src/opts/bitops.isle line 644.
                                                                returns.extend(Some(v920));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Bxor => {
                                            if v2.0 == v19.0 {
                                                let v99 = C::unpack_value_array_2(ctx, v98);
                                                if v7.1 == v99.1 {
                                                    // Rule at src/opts/bitops.isle line 216.
                                                    returns.extend(Some(v99.0));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    // Rule at src/opts/bitops.isle line 492.
                                                    returns.extend(Some(v99.0));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.1 == v99.0 {
                                                    // Rule at src/opts/bitops.isle line 490.
                                                    returns.extend(Some(v99.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 v343 = C::ty_int_vec128(ctx, v2.0);
                                            if let Some(v344) = v343 {
                                                if v19.0 == v344 {
                                                    let v345 = constructor_iconst_s(ctx, v344, -1_i64);
                                                    let v346 = C::subsume(ctx, v345);
                                                    // Rule at src/opts/bitops.isle line 23.
                                                    returns.extend(Some(v346));
                                                    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 v1025 = constructor_bxor(ctx, v2.0, v7.1, v7.0);
                                            // Rule at src/opts/cprop.isle line 164.
                                            returns.extend(Some(v1025));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        let v1605 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 19.
                                        returns.extend(Some(v1605));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                _ => {}
                            }
                        }
                        if v7.0 == v7.1 {
                            let v339 = C::ty_int(ctx, v2.0);
                            if let Some(v340) = v339 {
                                let v341 = constructor_iconst_u(ctx, v340, 0x0_u64);
                                let v342 = C::subsume(ctx, v341);
                                // Rule at src/opts/bitops.isle line 17.
                                returns.extend(Some(v342));
                                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 v357 = constructor_bnot(ctx, v2.0, v7.0);
                                        // Rule at src/opts/bitops.isle line 72.
                                        returns.extend(Some(v357));
                                        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 v133,
                                    args: ref v134,
                                } => {
                                    if let &Opcode::Iconcat = v133 {
                                        let v135 = C::unpack_value_array_2(ctx, v134);
                                        let v1845 = constructor_rotl(ctx, v2.0, v7.0, v135.0);
                                        // Rule at src/opts/shifts.isle line 142.
                                        returns.extend(Some(v1845));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v26,
                                    arg: v27,
                                } => {
                                    match v26 {
                                        &Opcode::Ireduce => {
                                            let v1373 = C::value_type(ctx, v27);
                                            let v1834 = C::fits_in_64(ctx, v1373);
                                            if let Some(v1835) = v1834 {
                                                let v1840 = constructor_rotl(ctx, v2.0, v7.0, v27);
                                                // Rule at src/opts/shifts.isle line 126.
                                                returns.extend(Some(v1840));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        &Opcode::Uextend => {
                                            let v1840 = constructor_rotl(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 127.
                                            returns.extend(Some(v1840));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Sextend => {
                                            let v1840 = constructor_rotl(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 128.
                                            returns.extend(Some(v1840));
                                            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 v97,
                                                    args: ref v98,
                                                } => {
                                                    match v97 {
                                                        &Opcode::Rotl => {
                                                            if v2.0 == v19.0 {
                                                                let v99 = C::unpack_value_array_2(ctx, v98);
                                                                let v1858 = constructor_iadd_uextend(ctx, v99.1, v7.1);
                                                                let v1859 = constructor_rotl(ctx, v2.0, v99.0, v1858);
                                                                // Rule at src/opts/shifts.isle line 239.
                                                                returns.extend(Some(v1859));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                        &Opcode::Rotr => {
                                                            if v2.0 == v19.0 {
                                                                let v99 = C::unpack_value_array_2(ctx, v98);
                                                                let v1861 = constructor_isub_uextend(ctx, v99.1, v7.1);
                                                                let v1863 = constructor_rotr(ctx, v2.0, v99.0, v1861);
                                                                // Rule at src/opts/shifts.isle line 246.
                                                                returns.extend(Some(v1863));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                &InstructionData::UnaryImm {
                                                    opcode: ref v22,
                                                    imm: v23,
                                                } => {
                                                    if let &Opcode::Iconst = v22 {
                                                        let v334 = C::fits_in_64(ctx, v2.0);
                                                        if let Some(v335) = v334 {
                                                            if v19.0 == v335 {
                                                                let v985 = C::imm64_rotl(ctx, v335, v23, v15);
                                                                let v986 = constructor_iconst(ctx, v335, v985);
                                                                let v987 = C::subsume(ctx, v986);
                                                                // Rule at src/opts/cprop.isle line 98.
                                                                returns.extend(Some(v987));
                                                                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 v358 = constructor_ty_shift_mask(ctx, v2.0);
                                        let v1847 = C::u64_and(ctx, v16, v358);
                                        let v1897 = C::u64_eq(ctx, v16, v1847);
                                        if v1897 == false {
                                            let v1898 = constructor_iconst_u(ctx, v11.0, v1847);
                                            let v1903 = constructor_rotl(ctx, v2.0, v7.0, v1898);
                                            // Rule at src/opts/shifts.isle line 308.
                                            returns.extend(Some(v1903));
                                            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 v97,
                                    args: ref v98,
                                } => {
                                    match v97 {
                                        &Opcode::Rotl => {
                                            if v2.0 == v19.0 {
                                                let v99 = C::unpack_value_array_2(ctx, v98);
                                                let v1864 = C::value_type(ctx, v99.1);
                                                let v1865 = C::value_type(ctx, v7.1);
                                                if v1864 == v1865 {
                                                    let v1858 = constructor_iadd_uextend(ctx, v99.1, v7.1);
                                                    let v1859 = constructor_rotl(ctx, v2.0, v99.0, v1858);
                                                    // Rule at src/opts/shifts.isle line 260.
                                                    returns.extend(Some(v1859));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let mut v109 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                let mut v109 = v109.into_context_iter();
                                                while let Some(v110) = v109.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v127,
                                                        imm: v128,
                                                    } = &v110.1 {
                                                        if let &Opcode::Iconst = v127 {
                                                            let v1858 = constructor_iadd_uextend(ctx, v99.1, v7.1);
                                                            let v1859 = constructor_rotl(ctx, v2.0, v99.0, v1858);
                                                            // Rule at src/opts/shifts.isle line 238.
                                                            returns.extend(Some(v1859));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Rotr => {
                                            if v2.0 == v19.0 {
                                                let v99 = C::unpack_value_array_2(ctx, v98);
                                                if v7.1 == v99.1 {
                                                    let v1857 = C::subsume(ctx, v99.0);
                                                    // Rule at src/opts/shifts.isle line 203.
                                                    returns.extend(Some(v1857));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let v1864 = C::value_type(ctx, v99.1);
                                                let v1865 = C::value_type(ctx, v7.1);
                                                if v1864 == v1865 {
                                                    let v1861 = constructor_isub_uextend(ctx, v99.1, v7.1);
                                                    let v1863 = constructor_rotr(ctx, v2.0, v99.0, v1861);
                                                    // Rule at src/opts/shifts.isle line 265.
                                                    returns.extend(Some(v1863));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let mut v109 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                let mut v109 = v109.into_context_iter();
                                                while let Some(v110) = v109.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v127,
                                                        imm: v128,
                                                    } = &v110.1 {
                                                        if let &Opcode::Iconst = v127 {
                                                            let v1861 = constructor_isub_uextend(ctx, v99.1, v7.1);
                                                            let v1863 = constructor_rotr(ctx, v2.0, v99.0, v1861);
                                                            // Rule at src/opts/shifts.isle line 245.
                                                            returns.extend(Some(v1863));
                                                            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 v1849 = C::lane_type(ctx, v2.0);
                                            let v2019 = constructor_rotl(ctx, v1849, v30, v7.1);
                                            let v2020 = constructor_splat(ctx, v2.0, v2019);
                                            // Rule at src/opts/vector.isle line 68.
                                            returns.extend(Some(v2020));
                                            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 v133,
                                    args: ref v134,
                                } => {
                                    if let &Opcode::Iconcat = v133 {
                                        let v135 = C::unpack_value_array_2(ctx, v134);
                                        let v1844 = constructor_rotr(ctx, v2.0, v7.0, v135.0);
                                        // Rule at src/opts/shifts.isle line 141.
                                        returns.extend(Some(v1844));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                &InstructionData::Ternary {
                                    opcode: ref v1866,
                                    args: ref v1867,
                                } => {
                                    if let &Opcode::Select = v1866 {
                                        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 v1868 = C::unpack_value_array_3(ctx, v1867);
                                                            let mut v1872 = C::inst_data_value_etor_returns::default();
                                                            C::inst_data_value_etor(ctx, v1868.1, &mut v1872);
                                                            let mut v1872 = v1872.into_context_iter();
                                                            while let Some(v1873) = v1872.next(ctx) {
                                                                if let &InstructionData::UnaryImm {
                                                                    opcode: ref v1876,
                                                                    imm: v1877,
                                                                } = &v1873.1 {
                                                                    if let &Opcode::Iconst = v1876 {
                                                                        if v2.0 == v1873.0 {
                                                                            let mut v1878 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v1868.2, &mut v1878);
                                                                            let mut v1878 = v1878.into_context_iter();
                                                                            while let Some(v1879) = v1878.next(ctx) {
                                                                                if let &InstructionData::UnaryImm {
                                                                                    opcode: ref v1882,
                                                                                    imm: v1883,
                                                                                } = &v1879.1 {
                                                                                    if let &Opcode::Iconst = v1882 {
                                                                                        if v2.0 == v1879.0 {
                                                                                            let v1884 = C::imm64_rotr(ctx, v2.0, v23, v1877);
                                                                                            let v1885 = constructor_iconst(ctx, v2.0, v1884);
                                                                                            let v1886 = C::imm64_rotr(ctx, v2.0, v23, v1883);
                                                                                            let v1887 = constructor_iconst(ctx, v2.0, v1886);
                                                                                            let v1888 = constructor_select(ctx, v2.0, v1868.0, v1885, v1887);
                                                                                            // Rule at src/opts/shifts.isle line 269.
                                                                                            returns.extend(Some(v1888));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v26,
                                    arg: v27,
                                } => {
                                    match v26 {
                                        &Opcode::Ireduce => {
                                            let v1373 = C::value_type(ctx, v27);
                                            let v1834 = C::fits_in_64(ctx, v1373);
                                            if let Some(v1835) = v1834 {
                                                let v1839 = constructor_rotr(ctx, v2.0, v7.0, v27);
                                                // Rule at src/opts/shifts.isle line 123.
                                                returns.extend(Some(v1839));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        &Opcode::Uextend => {
                                            let v1839 = constructor_rotr(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 124.
                                            returns.extend(Some(v1839));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Sextend => {
                                            let v1839 = constructor_rotr(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 125.
                                            returns.extend(Some(v1839));
                                            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 v97,
                                                    args: ref v98,
                                                } => {
                                                    match v97 {
                                                        &Opcode::Rotl => {
                                                            if v2.0 == v19.0 {
                                                                let v99 = C::unpack_value_array_2(ctx, v98);
                                                                let v1861 = constructor_isub_uextend(ctx, v99.1, v7.1);
                                                                let v1862 = constructor_rotl(ctx, v2.0, v99.0, v1861);
                                                                // Rule at src/opts/shifts.isle line 244.
                                                                returns.extend(Some(v1862));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                        &Opcode::Rotr => {
                                                            if v2.0 == v19.0 {
                                                                let v99 = C::unpack_value_array_2(ctx, v98);
                                                                let v1858 = constructor_iadd_uextend(ctx, v99.1, v7.1);
                                                                let v1860 = constructor_rotr(ctx, v2.0, v99.0, v1858);
                                                                // Rule at src/opts/shifts.isle line 241.
                                                                returns.extend(Some(v1860));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                &InstructionData::UnaryImm {
                                                    opcode: ref v22,
                                                    imm: v23,
                                                } => {
                                                    if let &Opcode::Iconst = v22 {
                                                        let v334 = C::fits_in_64(ctx, v2.0);
                                                        if let Some(v335) = v334 {
                                                            if v19.0 == v335 {
                                                                let v982 = C::imm64_rotr(ctx, v335, v23, v15);
                                                                let v983 = constructor_iconst(ctx, v335, v982);
                                                                let v984 = C::subsume(ctx, v983);
                                                                // Rule at src/opts/cprop.isle line 93.
                                                                returns.extend(Some(v984));
                                                                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 v358 = constructor_ty_shift_mask(ctx, v2.0);
                                        let v1847 = C::u64_and(ctx, v16, v358);
                                        let v1897 = C::u64_eq(ctx, v16, v1847);
                                        if v1897 == false {
                                            let v1898 = constructor_iconst_u(ctx, v11.0, v1847);
                                            let v1902 = constructor_rotr(ctx, v2.0, v7.0, v1898);
                                            // Rule at src/opts/shifts.isle line 305.
                                            returns.extend(Some(v1902));
                                            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 v97,
                                    args: ref v98,
                                } => {
                                    match v97 {
                                        &Opcode::Rotl => {
                                            if v2.0 == v19.0 {
                                                let v99 = C::unpack_value_array_2(ctx, v98);
                                                if v7.1 == v99.1 {
                                                    let v1857 = C::subsume(ctx, v99.0);
                                                    // Rule at src/opts/shifts.isle line 204.
                                                    returns.extend(Some(v1857));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let v1864 = C::value_type(ctx, v99.1);
                                                let v1865 = C::value_type(ctx, v7.1);
                                                if v1864 == v1865 {
                                                    let v1861 = constructor_isub_uextend(ctx, v99.1, v7.1);
                                                    let v1862 = constructor_rotl(ctx, v2.0, v99.0, v1861);
                                                    // Rule at src/opts/shifts.isle line 263.
                                                    returns.extend(Some(v1862));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let mut v109 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                let mut v109 = v109.into_context_iter();
                                                while let Some(v110) = v109.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v127,
                                                        imm: v128,
                                                    } = &v110.1 {
                                                        if let &Opcode::Iconst = v127 {
                                                            let v1861 = constructor_isub_uextend(ctx, v99.1, v7.1);
                                                            let v1862 = constructor_rotl(ctx, v2.0, v99.0, v1861);
                                                            // Rule at src/opts/shifts.isle line 243.
                                                            returns.extend(Some(v1862));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Rotr => {
                                            if v2.0 == v19.0 {
                                                let v99 = C::unpack_value_array_2(ctx, v98);
                                                let v1864 = C::value_type(ctx, v99.1);
                                                let v1865 = C::value_type(ctx, v7.1);
                                                if v1864 == v1865 {
                                                    let v1858 = constructor_iadd_uextend(ctx, v99.1, v7.1);
                                                    let v1860 = constructor_rotr(ctx, v2.0, v99.0, v1858);
                                                    // Rule at src/opts/shifts.isle line 258.
                                                    returns.extend(Some(v1860));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let mut v109 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                let mut v109 = v109.into_context_iter();
                                                while let Some(v110) = v109.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v127,
                                                        imm: v128,
                                                    } = &v110.1 {
                                                        if let &Opcode::Iconst = v127 {
                                                            let v1858 = constructor_iadd_uextend(ctx, v99.1, v7.1);
                                                            let v1860 = constructor_rotr(ctx, v2.0, v99.0, v1858);
                                                            // Rule at src/opts/shifts.isle line 240.
                                                            returns.extend(Some(v1860));
                                                            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 v1849 = C::lane_type(ctx, v2.0);
                                            let v2021 = constructor_rotr(ctx, v1849, v30, v7.1);
                                            let v2022 = constructor_splat(ctx, v2.0, v2021);
                                            // Rule at src/opts/vector.isle line 71.
                                            returns.extend(Some(v2022));
                                            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 v133,
                                    args: ref v134,
                                } => {
                                    if let &Opcode::Iconcat = v133 {
                                        let v135 = C::unpack_value_array_2(ctx, v134);
                                        let v1841 = constructor_ishl(ctx, v2.0, v7.0, v135.0);
                                        // Rule at src/opts/shifts.isle line 138.
                                        returns.extend(Some(v1841));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v26,
                                    arg: v27,
                                } => {
                                    match v26 {
                                        &Opcode::Ireduce => {
                                            let v1373 = C::value_type(ctx, v27);
                                            let v1834 = C::fits_in_64(ctx, v1373);
                                            if let Some(v1835) = v1834 {
                                                let v1836 = constructor_ishl(ctx, v2.0, v7.0, v27);
                                                // Rule at src/opts/shifts.isle line 114.
                                                returns.extend(Some(v1836));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        &Opcode::Uextend => {
                                            let v1836 = constructor_ishl(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 115.
                                            returns.extend(Some(v1836));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Sextend => {
                                            let v1836 = constructor_ishl(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 116.
                                            returns.extend(Some(v1836));
                                            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 v97,
                                                    args: ref v98,
                                                } => {
                                                    match v97 {
                                                        &Opcode::Ishl => {
                                                            if v2.0 == v19.0 {
                                                                let v99 = C::unpack_value_array_2(ctx, v98);
                                                                let mut v109 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                                let mut v109 = v109.into_context_iter();
                                                                while let Some(v110) = v109.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v127,
                                                                        imm: v128,
                                                                    } = &v110.1 {
                                                                        if let &Opcode::Iconst = v127 {
                                                                            let v351 = C::u64_from_imm64(ctx, v128);
                                                                            let v358 = constructor_ty_shift_mask(ctx, v2.0);
                                                                            let v1846 = C::u64_and(ctx, v351, v358);
                                                                            let v16 = C::u64_from_imm64(ctx, v15);
                                                                            let v1847 = C::u64_and(ctx, v16, v358);
                                                                            let v1848 = C::u64_wrapping_add(ctx, v1846, v1847);
                                                                            let v1849 = C::lane_type(ctx, v2.0);
                                                                            let v1850 = C::ty_bits_u64(ctx, v1849);
                                                                            let v1851 = C::u64_lt(ctx, v1848, v1850);
                                                                            if v1851 == true {
                                                                                let v1852 = constructor_iconst_u(ctx, v110.0, v1848);
                                                                                let v1853 = constructor_ishl(ctx, v2.0, v99.0, v1852);
                                                                                // Rule at src/opts/shifts.isle line 151.
                                                                                returns.extend(Some(v1853));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                            let v1815 = C::ty_bits_u64(ctx, v2.0);
                                                                            let v1856 = C::u64_lt_eq(ctx, v1815, v1848);
                                                                            if v1856 == 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 v102 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v99.0, &mut v102);
                                                                let mut v102 = v102.into_context_iter();
                                                                while let Some(v103) = v102.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v1037,
                                                                        imm: v1038,
                                                                    } = &v103.1 {
                                                                        if let &Opcode::Iconst = v1037 {
                                                                            let v1118 = constructor_ishl(ctx, v2.0, v99.0, v7.1);
                                                                            let v1119 = constructor_ishl(ctx, v2.0, v1118, v99.1);
                                                                            // Rule at src/opts/cprop.isle line 300.
                                                                            returns.extend(Some(v1119));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &Opcode::Ushr => {
                                                            let v334 = C::fits_in_64(ctx, v2.0);
                                                            if let Some(v335) = v334 {
                                                                if v19.0 == v335 {
                                                                    let v99 = C::unpack_value_array_2(ctx, v98);
                                                                    let mut v109 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                                    let mut v109 = v109.into_context_iter();
                                                                    while let Some(v110) = v109.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v127,
                                                                            imm: v128,
                                                                        } = &v110.1 {
                                                                            if let &Opcode::Iconst = v127 {
                                                                                if v15 == v128 {
                                                                                    let v1806 = C::imm64(ctx, 0xffffffffffffffff_u64);
                                                                                    let v1807 = C::imm64_shl(ctx, v335, v1806, v128);
                                                                                    let v1808 = constructor_iconst(ctx, v335, v1807);
                                                                                    let v1809 = constructor_band(ctx, v335, v99.0, v1808);
                                                                                    // Rule at src/opts/shifts.isle line 26.
                                                                                    returns.extend(Some(v1809));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &Opcode::Sshr => {
                                                            let v334 = C::fits_in_64(ctx, v2.0);
                                                            if let Some(v335) = v334 {
                                                                if v19.0 == v335 {
                                                                    let v99 = C::unpack_value_array_2(ctx, v98);
                                                                    let mut v109 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                                    let mut v109 = v109.into_context_iter();
                                                                    while let Some(v110) = v109.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v127,
                                                                            imm: v128,
                                                                        } = &v110.1 {
                                                                            if let &Opcode::Iconst = v127 {
                                                                                if v15 == v128 {
                                                                                    let v1806 = C::imm64(ctx, 0xffffffffffffffff_u64);
                                                                                    let v1807 = C::imm64_shl(ctx, v335, v1806, v128);
                                                                                    let v1808 = constructor_iconst(ctx, v335, v1807);
                                                                                    let v1809 = constructor_band(ctx, v335, v99.0, v1808);
                                                                                    // Rule at src/opts/shifts.isle line 31.
                                                                                    returns.extend(Some(v1809));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                &InstructionData::UnaryImm {
                                                    opcode: ref v22,
                                                    imm: v23,
                                                } => {
                                                    if let &Opcode::Iconst = v22 {
                                                        let v334 = C::fits_in_64(ctx, v2.0);
                                                        if let Some(v335) = v334 {
                                                            if v19.0 == v335 {
                                                                let v973 = C::imm64_shl(ctx, v335, v23, v15);
                                                                let v974 = constructor_iconst(ctx, v335, v973);
                                                                let v975 = C::subsume(ctx, v974);
                                                                // Rule at src/opts/cprop.isle line 78.
                                                                returns.extend(Some(v975));
                                                                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 v358 = constructor_ty_shift_mask(ctx, v2.0);
                                        let v1847 = C::u64_and(ctx, v16, v358);
                                        let v1897 = C::u64_eq(ctx, v16, v1847);
                                        if v1897 == false {
                                            let v1898 = constructor_iconst_u(ctx, v11.0, v1847);
                                            let v1899 = constructor_ishl(ctx, v2.0, v7.0, v1898);
                                            // Rule at src/opts/shifts.isle line 296.
                                            returns.extend(Some(v1899));
                                            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 v1849 = C::lane_type(ctx, v2.0);
                                        let v2023 = constructor_ishl(ctx, v1849, v30, v7.1);
                                        let v2024 = constructor_splat(ctx, v2.0, v2023);
                                        // Rule at src/opts/vector.isle line 74.
                                        returns.extend(Some(v2024));
                                        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 v133,
                                    args: ref v134,
                                } => {
                                    if let &Opcode::Iconcat = v133 {
                                        let v135 = C::unpack_value_array_2(ctx, v134);
                                        let v1842 = constructor_ushr(ctx, v2.0, v7.0, v135.0);
                                        // Rule at src/opts/shifts.isle line 139.
                                        returns.extend(Some(v1842));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v26,
                                    arg: v27,
                                } => {
                                    match v26 {
                                        &Opcode::Ireduce => {
                                            let v1373 = C::value_type(ctx, v27);
                                            let v1834 = C::fits_in_64(ctx, v1373);
                                            if let Some(v1835) = v1834 {
                                                let v1837 = constructor_ushr(ctx, v2.0, v7.0, v27);
                                                // Rule at src/opts/shifts.isle line 117.
                                                returns.extend(Some(v1837));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        &Opcode::Uextend => {
                                            let v1837 = constructor_ushr(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 118.
                                            returns.extend(Some(v1837));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Sextend => {
                                            let v1837 = constructor_ushr(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 119.
                                            returns.extend(Some(v1837));
                                            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 v97,
                                                    args: ref v98,
                                                } => {
                                                    match v97 {
                                                        &Opcode::Imul => {
                                                            let v116 = C::ty_half_width(ctx, v2.0);
                                                            if let Some(v117) = v116 {
                                                                if v2.0 == v19.0 {
                                                                    let v99 = C::unpack_value_array_2(ctx, v98);
                                                                    let mut v102 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v99.0, &mut v102);
                                                                    let mut v102 = v102.into_context_iter();
                                                                    while let Some(v103) = v102.next(ctx) {
                                                                        if let &InstructionData::Unary {
                                                                            opcode: ref v106,
                                                                            arg: v107,
                                                                        } = &v103.1 {
                                                                            if let &Opcode::Uextend = v106 {
                                                                                let v108 = C::value_type(ctx, v107);
                                                                                let v118 = C::ty_equal(ctx, v108, v117);
                                                                                if v118 == true {
                                                                                    let v16 = C::u64_from_imm64(ctx, v15);
                                                                                    let v119 = C::ty_bits_u64(ctx, v108);
                                                                                    let v120 = C::u64_eq(ctx, v16, v119);
                                                                                    if v120 == true {
                                                                                        let mut v109 = C::inst_data_value_etor_returns::default();
                                                                                        C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                                                        let mut v109 = v109.into_context_iter();
                                                                                        while let Some(v110) = v109.next(ctx) {
                                                                                            if let &InstructionData::Unary {
                                                                                                opcode: ref v113,
                                                                                                arg: v114,
                                                                                            } = &v110.1 {
                                                                                                if let &Opcode::Uextend = v113 {
                                                                                                    let v115 = C::value_type(ctx, v114);
                                                                                                    if v108 == v115 {
                                                                                                        let v123 = constructor_umulhi(ctx, v108, v107, v114);
                                                                                                        let v124 = constructor_uextend(ctx, v2.0, v123);
                                                                                                        // Rule at src/opts/arithmetic.isle line 205.
                                                                                                        returns.extend(Some(v124));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &Opcode::Ishl => {
                                                            let v99 = C::unpack_value_array_2(ctx, v98);
                                                            let mut v109 = C::inst_data_value_etor_returns::default();
                                                            C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                            let mut v109 = v109.into_context_iter();
                                                            while let Some(v110) = v109.next(ctx) {
                                                                if let &InstructionData::UnaryImm {
                                                                    opcode: ref v127,
                                                                    imm: v128,
                                                                } = &v110.1 {
                                                                    if let &Opcode::Iconst = v127 {
                                                                        if v15 == v128 {
                                                                            let v334 = C::fits_in_64(ctx, v2.0);
                                                                            if let Some(v335) = v334 {
                                                                                let v1450 = C::ty_int(ctx, v335);
                                                                                if let Some(v1451) = v1450 {
                                                                                    if v19.0 == v1451 {
                                                                                        let v1810 = C::ty_mask(ctx, v1451);
                                                                                        let v1811 = C::imm64(ctx, v1810);
                                                                                        let v1812 = C::imm64_ushr(ctx, v1451, v1811, v128);
                                                                                        let v1813 = constructor_iconst(ctx, v1451, v1812);
                                                                                        let v1814 = constructor_band(ctx, v1451, v99.0, v1813);
                                                                                        // Rule at src/opts/shifts.isle line 40.
                                                                                        returns.extend(Some(v1814));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                            let v339 = C::ty_int(ctx, v2.0);
                                                                            if let Some(v340) = v339 {
                                                                                let v351 = C::u64_from_imm64(ctx, v128);
                                                                                let v1821 = C::u64_matches_non_zero(ctx, v351);
                                                                                if let Some(v1822) = v1821 {
                                                                                    if v1822 == true {
                                                                                        let v1823 = C::ty_bits(ctx, v340);
                                                                                        let v1824 = C::u8_into_u64(ctx, v1823);
                                                                                        let v1825 = C::u64_wrapping_sub(ctx, v1824, v351);
                                                                                        let v1826 = constructor_shift_amt_to_type(ctx, v1825);
                                                                                        if let Some(v1827) = v1826 {
                                                                                            if v19.0 == v340 {
                                                                                                let v1828 = constructor_ireduce(ctx, v1827, v99.0);
                                                                                                let v1830 = constructor_uextend(ctx, v340, v1828);
                                                                                                // Rule at src/opts/shifts.isle line 87.
                                                                                                returns.extend(Some(v1830));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &Opcode::Ushr => {
                                                            if v2.0 == v19.0 {
                                                                let v99 = C::unpack_value_array_2(ctx, v98);
                                                                let mut v109 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                                let mut v109 = v109.into_context_iter();
                                                                while let Some(v110) = v109.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v127,
                                                                        imm: v128,
                                                                    } = &v110.1 {
                                                                        if let &Opcode::Iconst = v127 {
                                                                            let v351 = C::u64_from_imm64(ctx, v128);
                                                                            let v358 = constructor_ty_shift_mask(ctx, v2.0);
                                                                            let v1846 = C::u64_and(ctx, v351, v358);
                                                                            let v16 = C::u64_from_imm64(ctx, v15);
                                                                            let v1847 = C::u64_and(ctx, v16, v358);
                                                                            let v1848 = C::u64_wrapping_add(ctx, v1846, v1847);
                                                                            let v1849 = C::lane_type(ctx, v2.0);
                                                                            let v1850 = C::ty_bits_u64(ctx, v1849);
                                                                            let v1851 = C::u64_lt(ctx, v1848, v1850);
                                                                            if v1851 == true {
                                                                                let v1852 = constructor_iconst_u(ctx, v110.0, v1848);
                                                                                let v1854 = constructor_ushr(ctx, v2.0, v99.0, v1852);
                                                                                // Rule at src/opts/shifts.isle line 160.
                                                                                returns.extend(Some(v1854));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                            let v1815 = C::ty_bits_u64(ctx, v2.0);
                                                                            let v1856 = C::u64_lt_eq(ctx, v1815, v1848);
                                                                            if v1856 == 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 v102 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v99.0, &mut v102);
                                                                let mut v102 = v102.into_context_iter();
                                                                while let Some(v103) = v102.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v1037,
                                                                        imm: v1038,
                                                                    } = &v103.1 {
                                                                        if let &Opcode::Iconst = v1037 {
                                                                            let v1120 = constructor_ushr(ctx, v2.0, v99.0, v7.1);
                                                                            let v1121 = constructor_ushr(ctx, v2.0, v1120, v99.1);
                                                                            // Rule at src/opts/cprop.isle line 302.
                                                                            returns.extend(Some(v1121));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                &InstructionData::UnaryImm {
                                                    opcode: ref v22,
                                                    imm: v23,
                                                } => {
                                                    if let &Opcode::Iconst = v22 {
                                                        let v334 = C::fits_in_64(ctx, v2.0);
                                                        if let Some(v335) = v334 {
                                                            if v19.0 == v335 {
                                                                let v976 = C::imm64_ushr(ctx, v335, v23, v15);
                                                                let v977 = constructor_iconst(ctx, v335, v976);
                                                                let v978 = C::subsume(ctx, v977);
                                                                // Rule at src/opts/cprop.isle line 83.
                                                                returns.extend(Some(v978));
                                                                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 v358 = constructor_ty_shift_mask(ctx, v2.0);
                                        let v1847 = C::u64_and(ctx, v16, v358);
                                        let v1897 = C::u64_eq(ctx, v16, v1847);
                                        if v1897 == false {
                                            let v1898 = constructor_iconst_u(ctx, v11.0, v1847);
                                            let v1900 = constructor_ushr(ctx, v2.0, v7.0, v1898);
                                            // Rule at src/opts/shifts.isle line 299.
                                            returns.extend(Some(v1900));
                                            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 v97,
                                    args: ref v98,
                                } => {
                                    if let &Opcode::Band = v97 {
                                        if v2.0 == v19.0 {
                                            let v99 = C::unpack_value_array_2(ctx, v98);
                                            let mut v102 = C::inst_data_value_etor_returns::default();
                                            C::inst_data_value_etor(ctx, v99.0, &mut v102);
                                            let mut v102 = v102.into_context_iter();
                                            while let Some(v103) = v102.next(ctx) {
                                                if let &InstructionData::Binary {
                                                    opcode: ref v284,
                                                    args: ref v285,
                                                } = &v103.1 {
                                                    if let &Opcode::Ishl = v284 {
                                                        if v2.0 == v103.0 {
                                                            let v286 = C::unpack_value_array_2(ctx, v285);
                                                            if v7.1 == v286.1 {
                                                                let v1907 = constructor_ushr(ctx, v2.0, v99.1, v286.1);
                                                                let v1908 = constructor_band(ctx, v2.0, v286.0, v1907);
                                                                // Rule at src/opts/shifts.isle line 316.
                                                                returns.extend(Some(v1908));
                                                                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 v1849 = C::lane_type(ctx, v2.0);
                                            let v2025 = constructor_ushr(ctx, v1849, v30, v7.1);
                                            let v2026 = constructor_splat(ctx, v2.0, v2025);
                                            // Rule at src/opts/vector.isle line 77.
                                            returns.extend(Some(v2026));
                                            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 v133,
                                    args: ref v134,
                                } => {
                                    if let &Opcode::Iconcat = v133 {
                                        let v135 = C::unpack_value_array_2(ctx, v134);
                                        let v1843 = constructor_sshr(ctx, v2.0, v7.0, v135.0);
                                        // Rule at src/opts/shifts.isle line 140.
                                        returns.extend(Some(v1843));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v26,
                                    arg: v27,
                                } => {
                                    match v26 {
                                        &Opcode::Ireduce => {
                                            let v1373 = C::value_type(ctx, v27);
                                            let v1834 = C::fits_in_64(ctx, v1373);
                                            if let Some(v1835) = v1834 {
                                                let v1838 = constructor_sshr(ctx, v2.0, v7.0, v27);
                                                // Rule at src/opts/shifts.isle line 120.
                                                returns.extend(Some(v1838));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        &Opcode::Uextend => {
                                            let v1838 = constructor_sshr(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 121.
                                            returns.extend(Some(v1838));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Sextend => {
                                            let v1838 = constructor_sshr(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 122.
                                            returns.extend(Some(v1838));
                                            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 v97,
                                                    args: ref v98,
                                                } => {
                                                    match v97 {
                                                        &Opcode::Imul => {
                                                            let v116 = C::ty_half_width(ctx, v2.0);
                                                            if let Some(v117) = v116 {
                                                                if v2.0 == v19.0 {
                                                                    let v99 = C::unpack_value_array_2(ctx, v98);
                                                                    let mut v102 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v99.0, &mut v102);
                                                                    let mut v102 = v102.into_context_iter();
                                                                    while let Some(v103) = v102.next(ctx) {
                                                                        if let &InstructionData::Unary {
                                                                            opcode: ref v106,
                                                                            arg: v107,
                                                                        } = &v103.1 {
                                                                            if let &Opcode::Sextend = v106 {
                                                                                let v108 = C::value_type(ctx, v107);
                                                                                let v118 = C::ty_equal(ctx, v108, v117);
                                                                                if v118 == true {
                                                                                    let v16 = C::u64_from_imm64(ctx, v15);
                                                                                    let v119 = C::ty_bits_u64(ctx, v108);
                                                                                    let v120 = C::u64_eq(ctx, v16, v119);
                                                                                    if v120 == true {
                                                                                        let mut v109 = C::inst_data_value_etor_returns::default();
                                                                                        C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                                                        let mut v109 = v109.into_context_iter();
                                                                                        while let Some(v110) = v109.next(ctx) {
                                                                                            if let &InstructionData::Unary {
                                                                                                opcode: ref v113,
                                                                                                arg: v114,
                                                                                            } = &v110.1 {
                                                                                                if let &Opcode::Sextend = v113 {
                                                                                                    let v115 = C::value_type(ctx, v114);
                                                                                                    if v108 == v115 {
                                                                                                        let v121 = constructor_smulhi(ctx, v108, v107, v114);
                                                                                                        let v122 = constructor_sextend(ctx, v2.0, v121);
                                                                                                        // Rule at src/opts/arithmetic.isle line 199.
                                                                                                        returns.extend(Some(v122));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &Opcode::Bor => {
                                                            let v16 = C::u64_from_imm64(ctx, v15);
                                                            let v358 = constructor_ty_shift_mask(ctx, v2.0);
                                                            let v359 = C::u64_eq(ctx, v16, v358);
                                                            if v359 == true {
                                                                if v2.0 == v11.0 {
                                                                    if v2.0 == v19.0 {
                                                                        let v99 = C::unpack_value_array_2(ctx, v98);
                                                                        let mut v102 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v99.0, &mut v102);
                                                                        let mut v102 = v102.into_context_iter();
                                                                        while let Some(v103) = v102.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v106,
                                                                                arg: v107,
                                                                            } = &v103.1 {
                                                                                if let &Opcode::Ineg = v106 {
                                                                                    if v2.0 == v103.0 {
                                                                                        if v99.1 == v107 {
                                                                                            let v361 = constructor_bmask(ctx, v2.0, v107);
                                                                                            // Rule at src/opts/bitops.isle line 83.
                                                                                            returns.extend(Some(v361));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let mut v109 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                                        let mut v109 = v109.into_context_iter();
                                                                        while let Some(v110) = v109.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v113,
                                                                                arg: v114,
                                                                            } = &v110.1 {
                                                                                if let &Opcode::Ineg = v113 {
                                                                                    if v99.0 == v114 {
                                                                                        if v2.0 == v110.0 {
                                                                                            let v360 = constructor_bmask(ctx, v2.0, v99.0);
                                                                                            // Rule at src/opts/bitops.isle line 79.
                                                                                            returns.extend(Some(v360));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &Opcode::Ishl => {
                                                            let v99 = C::unpack_value_array_2(ctx, v98);
                                                            let mut v109 = C::inst_data_value_etor_returns::default();
                                                            C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                            let mut v109 = v109.into_context_iter();
                                                            while let Some(v110) = v109.next(ctx) {
                                                                if let &InstructionData::UnaryImm {
                                                                    opcode: ref v127,
                                                                    imm: v128,
                                                                } = &v110.1 {
                                                                    if let &Opcode::Iconst = v127 {
                                                                        if v2.0 == v19.0 {
                                                                            let v16 = C::u64_from_imm64(ctx, v15);
                                                                            let v351 = C::u64_from_imm64(ctx, v128);
                                                                            if v16 == v351 {
                                                                                let mut v102 = C::inst_data_value_etor_returns::default();
                                                                                C::inst_data_value_etor(ctx, v99.0, &mut v102);
                                                                                let mut v102 = v102.into_context_iter();
                                                                                while let Some(v103) = v102.next(ctx) {
                                                                                    if let &InstructionData::Unary {
                                                                                        opcode: ref v106,
                                                                                        arg: v107,
                                                                                    } = &v103.1 {
                                                                                        match v106 {
                                                                                            &Opcode::Uextend => {
                                                                                                if v2.0 == v103.0 {
                                                                                                    let v1815 = C::ty_bits_u64(ctx, v2.0);
                                                                                                    let v108 = C::value_type(ctx, v107);
                                                                                                    let v119 = C::ty_bits_u64(ctx, v108);
                                                                                                    let v1816 = C::u64_wrapping_sub(ctx, v1815, v119);
                                                                                                    let v1817 = C::u64_eq(ctx, v351, v1816);
                                                                                                    if v1817 == true {
                                                                                                        let v1818 = constructor_sextend(ctx, v2.0, v107);
                                                                                                        // Rule at src/opts/shifts.isle line 49.
                                                                                                        returns.extend(Some(v1818));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                    let v1819 = C::u64_lt(ctx, v351, v1816);
                                                                                                    if v1819 == true {
                                                                                                        // Rule at src/opts/shifts.isle line 60.
                                                                                                        returns.extend(Some(v99.0));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                            &Opcode::Sextend => {
                                                                                                let v1815 = C::ty_bits_u64(ctx, v2.0);
                                                                                                let v108 = C::value_type(ctx, v107);
                                                                                                let v119 = C::ty_bits_u64(ctx, v108);
                                                                                                let v1816 = C::u64_wrapping_sub(ctx, v1815, v119);
                                                                                                let v1820 = C::u64_lt_eq(ctx, v351, v1816);
                                                                                                if v1820 == true {
                                                                                                    if v2.0 == v103.0 {
                                                                                                        // Rule at src/opts/shifts.isle line 70.
                                                                                                        returns.extend(Some(v99.0));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                            _ => {}
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        if v15 == v128 {
                                                                            let v339 = C::ty_int(ctx, v2.0);
                                                                            if let Some(v340) = v339 {
                                                                                if v19.0 == v340 {
                                                                                    let v351 = C::u64_from_imm64(ctx, v128);
                                                                                    let v1821 = C::u64_matches_non_zero(ctx, v351);
                                                                                    if let Some(v1822) = v1821 {
                                                                                        if v1822 == true {
                                                                                            let v1823 = C::ty_bits(ctx, v340);
                                                                                            let v1824 = C::u8_into_u64(ctx, v1823);
                                                                                            let v1825 = C::u64_wrapping_sub(ctx, v1824, v351);
                                                                                            let v1826 = constructor_shift_amt_to_type(ctx, v1825);
                                                                                            if let Some(v1827) = v1826 {
                                                                                                let v1828 = constructor_ireduce(ctx, v1827, v99.0);
                                                                                                let v1829 = constructor_sextend(ctx, v340, v1828);
                                                                                                // Rule at src/opts/shifts.isle line 83.
                                                                                                returns.extend(Some(v1829));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &Opcode::Sshr => {
                                                            if v2.0 == v19.0 {
                                                                let v99 = C::unpack_value_array_2(ctx, v98);
                                                                let mut v102 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v99.0, &mut v102);
                                                                let mut v102 = v102.into_context_iter();
                                                                while let Some(v103) = v102.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v1037,
                                                                        imm: v1038,
                                                                    } = &v103.1 {
                                                                        if let &Opcode::Iconst = v1037 {
                                                                            let v1122 = constructor_sshr(ctx, v2.0, v99.0, v7.1);
                                                                            let v1123 = constructor_sshr(ctx, v2.0, v1122, v99.1);
                                                                            // Rule at src/opts/cprop.isle line 304.
                                                                            returns.extend(Some(v1123));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                let mut v109 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v99.1, &mut v109);
                                                                let mut v109 = v109.into_context_iter();
                                                                while let Some(v110) = v109.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v127,
                                                                        imm: v128,
                                                                    } = &v110.1 {
                                                                        if let &Opcode::Iconst = v127 {
                                                                            let v351 = C::u64_from_imm64(ctx, v128);
                                                                            let v358 = constructor_ty_shift_mask(ctx, v2.0);
                                                                            let v1846 = C::u64_and(ctx, v351, v358);
                                                                            let v16 = C::u64_from_imm64(ctx, v15);
                                                                            let v1847 = C::u64_and(ctx, v16, v358);
                                                                            let v1848 = C::u64_wrapping_add(ctx, v1846, v1847);
                                                                            let v1849 = C::lane_type(ctx, v2.0);
                                                                            let v1850 = C::ty_bits_u64(ctx, v1849);
                                                                            let v1851 = C::u64_lt(ctx, v1848, v1850);
                                                                            if v1851 == true {
                                                                                let v1852 = constructor_iconst_u(ctx, v110.0, v1848);
                                                                                let v1855 = constructor_sshr(ctx, v2.0, v99.0, v1852);
                                                                                // Rule at src/opts/shifts.isle line 169.
                                                                                returns.extend(Some(v1855));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                &InstructionData::UnaryImm {
                                                    opcode: ref v22,
                                                    imm: v23,
                                                } => {
                                                    if let &Opcode::Iconst = v22 {
                                                        let v334 = C::fits_in_64(ctx, v2.0);
                                                        if let Some(v335) = v334 {
                                                            if v19.0 == v335 {
                                                                let v979 = C::imm64_sshr(ctx, v335, v23, v15);
                                                                let v980 = constructor_iconst(ctx, v335, v979);
                                                                let v981 = C::subsume(ctx, v980);
                                                                // Rule at src/opts/cprop.isle line 88.
                                                                returns.extend(Some(v981));
                                                                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 v358 = constructor_ty_shift_mask(ctx, v2.0);
                                        let v1847 = C::u64_and(ctx, v16, v358);
                                        let v1897 = C::u64_eq(ctx, v16, v1847);
                                        if v1897 == false {
                                            let v1898 = constructor_iconst_u(ctx, v11.0, v1847);
                                            let v1901 = constructor_sshr(ctx, v2.0, v7.0, v1898);
                                            // Rule at src/opts/shifts.isle line 302.
                                            returns.extend(Some(v1901));
                                            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 v1849 = C::lane_type(ctx, v2.0);
                                        let v2027 = constructor_sshr(ctx, v1849, v30, v7.1);
                                        let v2028 = constructor_splat(ctx, v2.0, v2027);
                                        // Rule at src/opts/vector.isle line 80.
                                        returns.extend(Some(v2028));
                                        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 v1162,
                                            imm: v1163,
                                        } = &v11.1 {
                                            if let &Opcode::F32const = v1162 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                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 v1160,
                                                            imm: v1161,
                                                        } = &v19.1 {
                                                            if let &Opcode::F32const = v1160 {
                                                                let v1164 = C::f32_add(ctx, v1161, v1163);
                                                                if let Some(v1165) = v1164 {
                                                                    let v1166 = constructor_f32const(ctx, F32, v1165);
                                                                    let v1167 = C::subsume(ctx, v1166);
                                                                    // Rule at src/opts/cprop.isle line 378.
                                                                    returns.extend(Some(v1167));
                                                                    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 v1170,
                                            imm: v1171,
                                        } = &v11.1 {
                                            if let &Opcode::F64const = v1170 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                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 v1168,
                                                            imm: v1169,
                                                        } = &v19.1 {
                                                            if let &Opcode::F64const = v1168 {
                                                                let v1172 = C::f64_add(ctx, v1169, v1171);
                                                                if let Some(v1173) = v1172 {
                                                                    let v1174 = constructor_f64const(ctx, F64, v1173);
                                                                    let v1175 = C::subsume(ctx, v1174);
                                                                    // Rule at src/opts/cprop.isle line 381.
                                                                    returns.extend(Some(v1175));
                                                                    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 v1162,
                                            imm: v1163,
                                        } = &v11.1 {
                                            if let &Opcode::F32const = v1162 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                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 v1160,
                                                            imm: v1161,
                                                        } = &v19.1 {
                                                            if let &Opcode::F32const = v1160 {
                                                                let v1176 = C::f32_sub(ctx, v1161, v1163);
                                                                if let Some(v1177) = v1176 {
                                                                    let v1178 = constructor_f32const(ctx, F32, v1177);
                                                                    let v1179 = C::subsume(ctx, v1178);
                                                                    // Rule at src/opts/cprop.isle line 385.
                                                                    returns.extend(Some(v1179));
                                                                    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 v1170,
                                            imm: v1171,
                                        } = &v11.1 {
                                            if let &Opcode::F64const = v1170 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                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 v1168,
                                                            imm: v1169,
                                                        } = &v19.1 {
                                                            if let &Opcode::F64const = v1168 {
                                                                let v1180 = C::f64_sub(ctx, v1169, v1171);
                                                                if let Some(v1181) = v1180 {
                                                                    let v1182 = constructor_f64const(ctx, F64, v1181);
                                                                    let v1183 = C::subsume(ctx, v1182);
                                                                    // Rule at src/opts/cprop.isle line 388.
                                                                    returns.extend(Some(v1183));
                                                                    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 v96 = constructor_fmul(ctx, v2.0, v30, v27);
                                                            // Rule at src/opts/arithmetic.isle line 193.
                                                            returns.extend(Some(v96));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryIeee32 {
                                    opcode: ref v1162,
                                    imm: v1163,
                                } => {
                                    if let &Opcode::F32const = v1162 {
                                        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 v1160,
                                                            imm: v1161,
                                                        } = &v19.1 {
                                                            if let &Opcode::F32const = v1160 {
                                                                let v1184 = C::f32_mul(ctx, v1161, v1163);
                                                                if let Some(v1185) = v1184 {
                                                                    let v1186 = constructor_f32const(ctx, F32, v1185);
                                                                    let v1187 = C::subsume(ctx, v1186);
                                                                    // Rule at src/opts/cprop.isle line 392.
                                                                    returns.extend(Some(v1187));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryIeee64 {
                                    opcode: ref v1170,
                                    imm: v1171,
                                } => {
                                    if let &Opcode::F64const = v1170 {
                                        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 v1168,
                                                            imm: v1169,
                                                        } = &v19.1 {
                                                            if let &Opcode::F64const = v1168 {
                                                                let v1188 = C::f64_mul(ctx, v1169, v1171);
                                                                if let Some(v1189) = v1188 {
                                                                    let v1190 = constructor_f64const(ctx, F64, v1189);
                                                                    let v1191 = C::subsume(ctx, v1190);
                                                                    // Rule at src/opts/cprop.isle line 395.
                                                                    returns.extend(Some(v1191));
                                                                    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 v1162,
                                            imm: v1163,
                                        } = &v11.1 {
                                            if let &Opcode::F32const = v1162 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                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 v1160,
                                                            imm: v1161,
                                                        } = &v19.1 {
                                                            if let &Opcode::F32const = v1160 {
                                                                let v1192 = C::f32_div(ctx, v1161, v1163);
                                                                if let Some(v1193) = v1192 {
                                                                    let v1194 = constructor_f32const(ctx, F32, v1193);
                                                                    let v1195 = C::subsume(ctx, v1194);
                                                                    // Rule at src/opts/cprop.isle line 399.
                                                                    returns.extend(Some(v1195));
                                                                    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 v1170,
                                            imm: v1171,
                                        } = &v11.1 {
                                            if let &Opcode::F64const = v1170 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                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 v1168,
                                                            imm: v1169,
                                                        } = &v19.1 {
                                                            if let &Opcode::F64const = v1168 {
                                                                let v1196 = C::f64_div(ctx, v1169, v1171);
                                                                if let Some(v1197) = v1196 {
                                                                    let v1198 = constructor_f64const(ctx, F64, v1197);
                                                                    let v1199 = C::subsume(ctx, v1198);
                                                                    // Rule at src/opts/cprop.isle line 402.
                                                                    returns.extend(Some(v1199));
                                                                    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 v1242,
                                            imm: v1243,
                                        } = &v11.1 {
                                            if let &Opcode::F16const = v1242 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                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 v1240,
                                                            imm: v1241,
                                                        } = &v19.1 {
                                                            if let &Opcode::F16const = v1240 {
                                                                let v1320 = C::f16_copysign(ctx, v1241, v1243);
                                                                let v1321 = constructor_f16const(ctx, F16, v1320);
                                                                let v1322 = C::subsume(ctx, v1321);
                                                                // Rule at src/opts/cprop.isle line 485.
                                                                returns.extend(Some(v1322));
                                                                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 v1162,
                                            imm: v1163,
                                        } = &v11.1 {
                                            if let &Opcode::F32const = v1162 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                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 v1160,
                                                            imm: v1161,
                                                        } = &v19.1 {
                                                            if let &Opcode::F32const = v1160 {
                                                                let v1323 = C::f32_copysign(ctx, v1161, v1163);
                                                                let v1324 = constructor_f32const(ctx, F32, v1323);
                                                                let v1325 = C::subsume(ctx, v1324);
                                                                // Rule at src/opts/cprop.isle line 487.
                                                                returns.extend(Some(v1325));
                                                                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 v1170,
                                            imm: v1171,
                                        } = &v11.1 {
                                            if let &Opcode::F64const = v1170 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                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 v1168,
                                                            imm: v1169,
                                                        } = &v19.1 {
                                                            if let &Opcode::F64const = v1168 {
                                                                let v1326 = C::f64_copysign(ctx, v1169, v1171);
                                                                let v1327 = constructor_f64const(ctx, F64, v1326);
                                                                let v1328 = C::subsume(ctx, v1327);
                                                                // Rule at src/opts/cprop.isle line 489.
                                                                returns.extend(Some(v1328));
                                                                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 v1261,
                                            constant_handle: v1262,
                                        } = &v11.1 {
                                            if let &Opcode::F128const = v1261 {
                                                let v1263 = C::ieee128_constant_extractor(ctx, v1262);
                                                if let Some(v1264) = v1263 {
                                                    let mut v18 = C::inst_data_value_etor_returns::default();
                                                    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 v1257,
                                                                constant_handle: v1258,
                                                            } = &v19.1 {
                                                                if let &Opcode::F128const = v1257 {
                                                                    let v1259 = C::ieee128_constant_extractor(ctx, v1258);
                                                                    if let Some(v1260) = v1259 {
                                                                        let v1329 = C::f128_copysign(ctx, v1260, v1264);
                                                                        let v1330 = C::ieee128_constant(ctx, v1329);
                                                                        let v1331 = constructor_f128const(ctx, F128, v1330);
                                                                        let v1332 = C::subsume(ctx, v1331);
                                                                        // Rule at src/opts/cprop.isle line 491.
                                                                        returns.extend(Some(v1332));
                                                                        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 v1242,
                                            imm: v1243,
                                        } = &v11.1 {
                                            if let &Opcode::F16const = v1242 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                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 v1240,
                                                            imm: v1241,
                                                        } = &v19.1 {
                                                            if let &Opcode::F16const = v1240 {
                                                                let v1244 = C::f16_min(ctx, v1241, v1243);
                                                                if let Some(v1245) = v1244 {
                                                                    let v1247 = constructor_f16const(ctx, F16, v1245);
                                                                    let v1248 = C::subsume(ctx, v1247);
                                                                    // Rule at src/opts/cprop.isle line 441.
                                                                    returns.extend(Some(v1248));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            F32 => {
                                let v7 = C::unpack_value_array_2(ctx, v6);
                                let mut v10 = C::inst_data_value_etor_returns::default();
                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
                                let mut v10 = v10.into_context_iter();
                                while let Some(v11) = v10.next(ctx) {
                                    if v11.0 == F32 {
                                        if let &InstructionData::UnaryIeee32 {
                                            opcode: ref v1162,
                                            imm: v1163,
                                        } = &v11.1 {
                                            if let &Opcode::F32const = v1162 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                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 v1160,
                                                            imm: v1161,
                                                        } = &v19.1 {
                                                            if let &Opcode::F32const = v1160 {
                                                                let v1249 = C::f32_min(ctx, v1161, v1163);
                                                                if let Some(v1250) = v1249 {
                                                                    let v1251 = constructor_f32const(ctx, F32, v1250);
                                                                    let v1252 = C::subsume(ctx, v1251);
                                                                    // Rule at src/opts/cprop.isle line 444.
                                                                    returns.extend(Some(v1252));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            F64 => {
                                let v7 = C::unpack_value_array_2(ctx, v6);
                                let mut v10 = C::inst_data_value_etor_returns::default();
                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
                                let mut v10 = v10.into_context_iter();
                                while let Some(v11) = v10.next(ctx) {
                                    if v11.0 == F64 {
                                        if let &InstructionData::UnaryIeee64 {
                                            opcode: ref v1170,
                                            imm: v1171,
                                        } = &v11.1 {
                                            if let &Opcode::F64const = v1170 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                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 v1168,
                                                            imm: v1169,
                                                        } = &v19.1 {
                                                            if let &Opcode::F64const = v1168 {
                                                                let v1253 = C::f64_min(ctx, v1169, v1171);
                                                                if let Some(v1254) = v1253 {
                                                                    let v1255 = constructor_f64const(ctx, F64, v1254);
                                                                    let v1256 = C::subsume(ctx, v1255);
                                                                    // Rule at src/opts/cprop.isle line 447.
                                                                    returns.extend(Some(v1256));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            F128 => {
                                let v7 = C::unpack_value_array_2(ctx, v6);
                                let mut v10 = C::inst_data_value_etor_returns::default();
                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
                                let mut v10 = v10.into_context_iter();
                                while let Some(v11) = v10.next(ctx) {
                                    if v11.0 == F128 {
                                        if let &InstructionData::UnaryConst {
                                            opcode: ref v1261,
                                            constant_handle: v1262,
                                        } = &v11.1 {
                                            if let &Opcode::F128const = v1261 {
                                                let v1263 = C::ieee128_constant_extractor(ctx, v1262);
                                                if let Some(v1264) = v1263 {
                                                    let mut v18 = C::inst_data_value_etor_returns::default();
                                                    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 v1257,
                                                                constant_handle: v1258,
                                                            } = &v19.1 {
                                                                if let &Opcode::F128const = v1257 {
                                                                    let v1259 = C::ieee128_constant_extractor(ctx, v1258);
                                                                    if let Some(v1260) = v1259 {
                                                                        let v1265 = C::f128_min(ctx, v1260, v1264);
                                                                        if let Some(v1266) = v1265 {
                                                                            let v1268 = C::ieee128_constant(ctx, v1266);
                                                                            let v1269 = constructor_f128const(ctx, F128, v1268);
                                                                            let v1270 = C::subsume(ctx, v1269);
                                                                            // Rule at src/opts/cprop.isle line 450.
                                                                            returns.extend(Some(v1270));
                                                                            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 v1242,
                                            imm: v1243,
                                        } = &v11.1 {
                                            if let &Opcode::F16const = v1242 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                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 v1240,
                                                            imm: v1241,
                                                        } = &v19.1 {
                                                            if let &Opcode::F16const = v1240 {
                                                                let v1271 = C::f16_max(ctx, v1241, v1243);
                                                                if let Some(v1272) = v1271 {
                                                                    let v1273 = constructor_f16const(ctx, F16, v1272);
                                                                    let v1274 = C::subsume(ctx, v1273);
                                                                    // Rule at src/opts/cprop.isle line 454.
                                                                    returns.extend(Some(v1274));
                                                                    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 v1162,
                                            imm: v1163,
                                        } = &v11.1 {
                                            if let &Opcode::F32const = v1162 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                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 v1160,
                                                            imm: v1161,
                                                        } = &v19.1 {
                                                            if let &Opcode::F32const = v1160 {
                                                                let v1275 = C::f32_max(ctx, v1161, v1163);
                                                                if let Some(v1276) = v1275 {
                                                                    let v1277 = constructor_f32const(ctx, F32, v1276);
                                                                    let v1278 = C::subsume(ctx, v1277);
                                                                    // Rule at src/opts/cprop.isle line 457.
                                                                    returns.extend(Some(v1278));
                                                                    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 v1170,
                                            imm: v1171,
                                        } = &v11.1 {
                                            if let &Opcode::F64const = v1170 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                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 v1168,
                                                            imm: v1169,
                                                        } = &v19.1 {
                                                            if let &Opcode::F64const = v1168 {
                                                                let v1279 = C::f64_max(ctx, v1169, v1171);
                                                                if let Some(v1280) = v1279 {
                                                                    let v1281 = constructor_f64const(ctx, F64, v1280);
                                                                    let v1282 = C::subsume(ctx, v1281);
                                                                    // Rule at src/opts/cprop.isle line 460.
                                                                    returns.extend(Some(v1282));
                                                                    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 v1261,
                                            constant_handle: v1262,
                                        } = &v11.1 {
                                            if let &Opcode::F128const = v1261 {
                                                let v1263 = C::ieee128_constant_extractor(ctx, v1262);
                                                if let Some(v1264) = v1263 {
                                                    let mut v18 = C::inst_data_value_etor_returns::default();
                                                    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 v1257,
                                                                constant_handle: v1258,
                                                            } = &v19.1 {
                                                                if let &Opcode::F128const = v1257 {
                                                                    let v1259 = C::ieee128_constant_extractor(ctx, v1258);
                                                                    if let Some(v1260) = v1259 {
                                                                        let v1283 = C::f128_max(ctx, v1260, v1264);
                                                                        if let Some(v1284) = v1283 {
                                                                            let v1285 = C::ieee128_constant(ctx, v1284);
                                                                            let v1286 = constructor_f128const(ctx, F128, v1285);
                                                                            let v1287 = C::subsume(ctx, v1286);
                                                                            // Rule at src/opts/cprop.isle line 463.
                                                                            returns.extend(Some(v1287));
                                                                            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 v133,
                                        args: ref v134,
                                    } => {
                                        if let &Opcode::Sshr = v133 {
                                            let v135 = C::unpack_value_array_2(ctx, v134);
                                            if v7.0 == v135.0 {
                                                let mut v258 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v135.1, &mut v258);
                                                let mut v258 = v258.into_context_iter();
                                                while let Some(v259) = v258.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v1124,
                                                        imm: v1125,
                                                    } = &v259.1 {
                                                        if let &Opcode::Iconst = v1124 {
                                                            let v1393 = C::u64_from_imm64(ctx, v1125);
                                                            if v1393 == 0x3f_u64 {
                                                                let v1394 = constructor_sextend(ctx, I128, v7.0);
                                                                // Rule at src/opts/extends.isle line 94.
                                                                returns.extend(Some(v1394));
                                                                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 v1392 = constructor_uextend(ctx, I128, v7.0);
                                                // Rule at src/opts/extends.isle line 93.
                                                returns.extend(Some(v1392));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                        }
                    }
                    _ => {}
                }
            }
            &InstructionData::IntCompare {
                opcode: ref v147,
                args: ref v148,
                cond: ref v149,
            } => {
                if let &Opcode::Icmp = v147 {
                    match v149 {
                        &IntCC::Equal => {
                            let v150 = C::unpack_value_array_2(ctx, v148);
                            let mut v153 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v150.0, &mut v153);
                            let mut v153 = v153.into_context_iter();
                            while let Some(v154) = v153.next(ctx) {
                                match &v154.1 {
                                    &InstructionData::Binary {
                                        opcode: ref v198,
                                        args: ref v199,
                                    } => {
                                        match v198 {
                                            &Opcode::Iadd => {
                                                let mut v160 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v150.1, &mut v160);
                                                let mut v160 = v160.into_context_iter();
                                                while let Some(v161) = v160.next(ctx) {
                                                    match &v161.1 {
                                                        &InstructionData::Binary {
                                                            opcode: ref v164,
                                                            args: ref v165,
                                                        } => {
                                                            if let &Opcode::Iadd = v164 {
                                                                if v154.0 == v161.0 {
                                                                    let v166 = C::unpack_value_array_2(ctx, v165);
                                                                    let v200 = C::unpack_value_array_2(ctx, v199);
                                                                    if v166.0 == v200.0 {
                                                                        if v166.1 == v200.1 {
                                                                            let v290 = constructor_cmp_true(ctx, v2.0);
                                                                            // Rule at src/opts/arithmetic.isle line 388.
                                                                            returns.extend(Some(v290));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            // Rule at src/opts/arithmetic.isle line 389.
                                                                            returns.extend(Some(v290));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                    if v166.0 == v200.1 {
                                                                        if v166.1 == v200.0 {
                                                                            let v290 = constructor_cmp_true(ctx, v2.0);
                                                                            // Rule at src/opts/arithmetic.isle line 386.
                                                                            returns.extend(Some(v290));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            // Rule at src/opts/arithmetic.isle line 387.
                                                                            returns.extend(Some(v290));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                let v166 = C::unpack_value_array_2(ctx, v165);
                                                                let v200 = C::unpack_value_array_2(ctx, v199);
                                                                if v166.0 == v200.0 {
                                                                    let v730 = constructor_eq(ctx, v2.0, v200.1, v166.1);
                                                                    let v1400 = C::subsume(ctx, v730);
                                                                    // Rule at src/opts/icmp.isle line 26.
                                                                    returns.extend(Some(v1400));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v166.0 == v200.1 {
                                                                    let v726 = constructor_eq(ctx, v2.0, v200.0, v166.1);
                                                                    let v1398 = C::subsume(ctx, v726);
                                                                    // Rule at src/opts/icmp.isle line 22.
                                                                    returns.extend(Some(v1398));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v166.1 == v200.0 {
                                                                    let v728 = constructor_eq(ctx, v2.0, v200.1, v166.0);
                                                                    let v1399 = C::subsume(ctx, v728);
                                                                    // Rule at src/opts/icmp.isle line 24.
                                                                    returns.extend(Some(v1399));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v166.1 == v200.1 {
                                                                    let v724 = constructor_eq(ctx, v2.0, v200.0, v166.0);
                                                                    let v1397 = C::subsume(ctx, v724);
                                                                    // Rule at src/opts/icmp.isle line 20.
                                                                    returns.extend(Some(v1397));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                let mut v169 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v166.1, &mut v169);
                                                                let mut v169 = v169.into_context_iter();
                                                                while let Some(v170) = v169.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v173,
                                                                        imm: v174,
                                                                    } = &v170.1 {
                                                                        if let &Opcode::Iconst = v173 {
                                                                            let mut v203 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v200.1, &mut v203);
                                                                            let mut v203 = v203.into_context_iter();
                                                                            while let Some(v204) = v203.next(ctx) {
                                                                                if let &InstructionData::UnaryImm {
                                                                                    opcode: ref v207,
                                                                                    imm: v208,
                                                                                } = &v204.1 {
                                                                                    if let &Opcode::Iconst = v207 {
                                                                                        let v1078 = constructor_isub(ctx, v161.0, v166.1, v200.1);
                                                                                        let v1079 = constructor_iadd(ctx, v154.0, v166.0, v1078);
                                                                                        let v1080 = constructor_eq(ctx, v2.0, v200.0, v1079);
                                                                                        // Rule at src/opts/cprop.isle line 256.
                                                                                        returns.extend(Some(v1080));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::UnaryImm {
                                                            opcode: ref v210,
                                                            imm: v211,
                                                        } => {
                                                            if let &Opcode::Iconst = v210 {
                                                                let v200 = C::unpack_value_array_2(ctx, v199);
                                                                let mut v203 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v200.1, &mut v203);
                                                                let mut v203 = v203.into_context_iter();
                                                                while let Some(v204) = v203.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v207,
                                                                        imm: v208,
                                                                    } = &v204.1 {
                                                                        if let &Opcode::Iconst = v207 {
                                                                            let v1072 = constructor_isub(ctx, v154.0, v150.1, v200.1);
                                                                            let v1073 = constructor_eq(ctx, v2.0, v200.0, v1072);
                                                                            // Rule at src/opts/cprop.isle line 246.
                                                                            returns.extend(Some(v1073));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let v200 = C::unpack_value_array_2(ctx, v199);
                                                if v150.1 == v200.0 {
                                                    let v291 = constructor_iconst_u(ctx, v154.0, 0x0_u64);
                                                    let v295 = constructor_eq(ctx, v2.0, v200.1, v291);
                                                    // Rule at src/opts/arithmetic.isle line 401.
                                                    returns.extend(Some(v295));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v150.1 == v200.1 {
                                                    let v291 = constructor_iconst_u(ctx, v154.0, 0x0_u64);
                                                    let v297 = constructor_eq(ctx, v2.0, v200.0, v291);
                                                    // Rule at src/opts/arithmetic.isle line 400.
                                                    returns.extend(Some(v297));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                            &Opcode::Isub => {
                                                let v200 = C::unpack_value_array_2(ctx, v199);
                                                let mut v203 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v200.1, &mut v203);
                                                let mut v203 = v203.into_context_iter();
                                                while let Some(v204) = v203.next(ctx) {
                                                    match &v204.1 {
                                                        &InstructionData::IntCompare {
                                                            opcode: ref v1965,
                                                            args: ref v1966,
                                                            cond: ref v1967,
                                                        } => {
                                                            if let &Opcode::Icmp = v1965 {
                                                                match v1967 {
                                                                    &IntCC::SignedLessThan => {
                                                                        if v154.0 == I8 {
                                                                            let mut v220 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v200.0, &mut v220);
                                                                            let mut v220 = v220.into_context_iter();
                                                                            while let Some(v221) = v220.next(ctx) {
                                                                                if let &InstructionData::IntCompare {
                                                                                    opcode: ref v1959,
                                                                                    args: ref v1960,
                                                                                    cond: ref v1961,
                                                                                } = &v221.1 {
                                                                                    if let &Opcode::Icmp = v1959 {
                                                                                        if let &IntCC::SignedGreaterThan = v1961 {
                                                                                            if v204.0 == v221.0 {
                                                                                                let v1962 = C::unpack_value_array_2(ctx, v1960);
                                                                                                let v1968 = C::unpack_value_array_2(ctx, v1966);
                                                                                                if v1962.0 == v1968.0 {
                                                                                                    if v1962.1 == v1968.1 {
                                                                                                        let mut v1352 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                        C::inst_data_value_tupled_etor(ctx, v150.1, &mut v1352);
                                                                                                        let mut v1352 = v1352.into_context_iter();
                                                                                                        while let Some(v1353) = v1352.next(ctx) {
                                                                                                            let v1354 = C::iconst_sextend_etor(ctx, v1353);
                                                                                                            if let Some(v1355) = v1354 {
                                                                                                                match v1355.1 {
                                                                                                                    -1_i64 => {
                                                                                                                        let v1973 = constructor_slt(ctx, v221.0, v1962.0, v1962.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 178.
                                                                                                                        returns.extend(Some(v1973));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                    0_i64 => {
                                                                                                                        let v1971 = constructor_eq(ctx, v221.0, v1962.0, v1962.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 145.
                                                                                                                        returns.extend(Some(v1971));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                    1_i64 => {
                                                                                                                        let v1977 = constructor_sgt(ctx, v221.0, v1962.0, v1962.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 186.
                                                                                                                        returns.extend(Some(v1977));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                    _ => {}
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        if v154.0 == I8 {
                                                                            let mut v220 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v200.0, &mut v220);
                                                                            let mut v220 = v220.into_context_iter();
                                                                            while let Some(v221) = v220.next(ctx) {
                                                                                if let &InstructionData::IntCompare {
                                                                                    opcode: ref v1959,
                                                                                    args: ref v1960,
                                                                                    cond: ref v1961,
                                                                                } = &v221.1 {
                                                                                    if let &Opcode::Icmp = v1959 {
                                                                                        if let &IntCC::UnsignedGreaterThan = v1961 {
                                                                                            if v204.0 == v221.0 {
                                                                                                let v1962 = C::unpack_value_array_2(ctx, v1960);
                                                                                                let v1968 = C::unpack_value_array_2(ctx, v1966);
                                                                                                if v1962.0 == v1968.0 {
                                                                                                    if v1962.1 == v1968.1 {
                                                                                                        let mut v1352 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                        C::inst_data_value_tupled_etor(ctx, v150.1, &mut v1352);
                                                                                                        let mut v1352 = v1352.into_context_iter();
                                                                                                        while let Some(v1353) = v1352.next(ctx) {
                                                                                                            let v1354 = C::iconst_sextend_etor(ctx, v1353);
                                                                                                            if let Some(v1355) = v1354 {
                                                                                                                match v1355.1 {
                                                                                                                    -1_i64 => {
                                                                                                                        let v1974 = constructor_ult(ctx, v221.0, v1962.0, v1962.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 180.
                                                                                                                        returns.extend(Some(v1974));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                    0_i64 => {
                                                                                                                        let v1971 = constructor_eq(ctx, v221.0, v1962.0, v1962.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 147.
                                                                                                                        returns.extend(Some(v1971));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                    1_i64 => {
                                                                                                                        let v1978 = constructor_ugt(ctx, v221.0, v1962.0, v1962.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 188.
                                                                                                                        returns.extend(Some(v1978));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                    _ => {}
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::UnaryImm {
                                                            opcode: ref v207,
                                                            imm: v208,
                                                        } => {
                                                            if let &Opcode::Iconst = v207 {
                                                                let mut v160 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v150.1, &mut v160);
                                                                let mut v160 = v160.into_context_iter();
                                                                while let Some(v161) = v160.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v210,
                                                                        imm: v211,
                                                                    } = &v161.1 {
                                                                        if let &Opcode::Iconst = v210 {
                                                                            let v1075 = constructor_iadd(ctx, v154.0, v150.1, v200.1);
                                                                            let v1076 = constructor_eq(ctx, v2.0, v200.0, v1075);
                                                                            // Rule at src/opts/cprop.isle line 251.
                                                                            returns.extend(Some(v1076));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                if v150.1 == v200.0 {
                                                    let v291 = constructor_iconst_u(ctx, v154.0, 0x0_u64);
                                                    let v295 = constructor_eq(ctx, v2.0, v200.1, v291);
                                                    // Rule at src/opts/arithmetic.isle line 396.
                                                    returns.extend(Some(v295));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let mut v160 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v150.1, &mut v160);
                                                let mut v160 = v160.into_context_iter();
                                                while let Some(v161) = v160.next(ctx) {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v164,
                                                        args: ref v165,
                                                    } = &v161.1 {
                                                        if let &Opcode::Isub = v164 {
                                                            let v166 = C::unpack_value_array_2(ctx, v165);
                                                            let v1405 = constructor_iadd(ctx, v154.0, v200.0, v166.1);
                                                            let v1406 = constructor_iadd(ctx, v161.0, v166.0, v200.1);
                                                            let v1407 = constructor_eq(ctx, v2.0, v1405, v1406);
                                                            // Rule at src/opts/icmp.isle line 40.
                                                            returns.extend(Some(v1407));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                            }
                                            &Opcode::Imul => {
                                                let mut v160 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v150.1, &mut v160);
                                                let mut v160 = v160.into_context_iter();
                                                while let Some(v161) = v160.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v210,
                                                        imm: v211,
                                                    } = &v161.1 {
                                                        if let &Opcode::Iconst = v210 {
                                                            if v154.0 == v161.0 {
                                                                let v200 = C::unpack_value_array_2(ctx, v199);
                                                                let mut v203 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v200.1, &mut v203);
                                                                let mut v203 = v203.into_context_iter();
                                                                while let Some(v204) = v203.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v207,
                                                                        imm: v208,
                                                                    } = &v204.1 {
                                                                        if let &Opcode::Iconst = v207 {
                                                                            let v212 = C::u64_from_imm64(ctx, v211);
                                                                            let v209 = C::u64_from_imm64(ctx, v208);
                                                                            let v213 = C::u64_checked_rem(ctx, v212, v209);
                                                                            if let Some(v214) = v213 {
                                                                                if v214 == 0x0_u64 {
                                                                                    let v215 = C::u64_rem(ctx, v209, 0x2_u64);
                                                                                    if v215 == 0x1_u64 {
                                                                                        if v154.0 == v204.0 {
                                                                                            let v216 = C::u64_div(ctx, v212, v209);
                                                                                            let v217 = C::imm64(ctx, v216);
                                                                                            let v218 = constructor_iconst(ctx, v154.0, v217);
                                                                                            let v236 = constructor_eq(ctx, v2.0, v200.0, v218);
                                                                                            // Rule at src/opts/arithmetic.isle line 282.
                                                                                            returns.extend(Some(v236));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                let mut v220 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v200.0, &mut v220);
                                                                let mut v220 = v220.into_context_iter();
                                                                while let Some(v221) = v220.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v224,
                                                                        imm: v225,
                                                                    } = &v221.1 {
                                                                        if let &Opcode::Iconst = v224 {
                                                                            let v212 = C::u64_from_imm64(ctx, v211);
                                                                            let v226 = C::u64_from_imm64(ctx, v225);
                                                                            let v227 = C::u64_checked_rem(ctx, v212, v226);
                                                                            if let Some(v228) = v227 {
                                                                                if v228 == 0x0_u64 {
                                                                                    let v229 = C::u64_rem(ctx, v226, 0x2_u64);
                                                                                    if v229 == 0x1_u64 {
                                                                                        if v154.0 == v221.0 {
                                                                                            let v230 = C::u64_div(ctx, v212, v226);
                                                                                            let v231 = C::imm64(ctx, v230);
                                                                                            let v232 = constructor_iconst(ctx, v154.0, v231);
                                                                                            let v237 = constructor_eq(ctx, v2.0, v200.1, v232);
                                                                                            // Rule at src/opts/arithmetic.isle line 287.
                                                                                            returns.extend(Some(v237));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            &Opcode::Band => {
                                                let mut v160 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v150.1, &mut v160);
                                                let mut v160 = v160.into_context_iter();
                                                while let Some(v161) = v160.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v301,
                                                        arg: v302,
                                                    } = &v161.1 {
                                                        if let &Opcode::Bnot = v301 {
                                                            if v154.0 == v161.0 {
                                                                let v200 = C::unpack_value_array_2(ctx, v199);
                                                                let mut v203 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v200.1, &mut v203);
                                                                let mut v203 = v203.into_context_iter();
                                                                while let Some(v204) = v203.next(ctx) {
                                                                    if let &InstructionData::Unary {
                                                                        opcode: ref v932,
                                                                        arg: v933,
                                                                    } = &v204.1 {
                                                                        if let &Opcode::Bnot = v932 {
                                                                            if v302 == v933 {
                                                                                if v154.0 == v204.0 {
                                                                                    let v934 = constructor_bor(ctx, v154.0, v933, v200.0);
                                                                                    let v930 = constructor_iconst_s(ctx, v154.0, -1_i64);
                                                                                    let v935 = constructor_eq(ctx, v2.0, v934, v930);
                                                                                    // Rule at src/opts/bitops.isle line 692.
                                                                                    returns.extend(Some(v935));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                let mut v220 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v200.0, &mut v220);
                                                                let mut v220 = v220.into_context_iter();
                                                                while let Some(v221) = v220.next(ctx) {
                                                                    if let &InstructionData::Unary {
                                                                        opcode: ref v927,
                                                                        arg: v928,
                                                                    } = &v221.1 {
                                                                        if let &Opcode::Bnot = v927 {
                                                                            if v302 == v928 {
                                                                                if v154.0 == v221.0 {
                                                                                    let v929 = constructor_bor(ctx, v154.0, v928, v200.1);
                                                                                    let v930 = constructor_iconst_s(ctx, v154.0, -1_i64);
                                                                                    let v931 = constructor_eq(ctx, v2.0, v929, v930);
                                                                                    // Rule at src/opts/bitops.isle line 691.
                                                                                    returns.extend(Some(v931));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            &Opcode::Bxor => {
                                                let mut v160 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v150.1, &mut v160);
                                                let mut v160 = v160.into_context_iter();
                                                while let Some(v161) = v160.next(ctx) {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v164,
                                                        args: ref v165,
                                                    } = &v161.1 {
                                                        if let &Opcode::Bxor = v164 {
                                                            if v154.0 == v161.0 {
                                                                let v166 = C::unpack_value_array_2(ctx, v165);
                                                                let v200 = C::unpack_value_array_2(ctx, v199);
                                                                if v166.0 == v200.0 {
                                                                    let v730 = constructor_eq(ctx, v2.0, v200.1, v166.1);
                                                                    // Rule at src/opts/bitops.isle line 309.
                                                                    returns.extend(Some(v730));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    let v731 = constructor_eq(ctx, v2.0, v166.1, v200.1);
                                                                    // Rule at src/opts/bitops.isle line 310.
                                                                    returns.extend(Some(v731));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v166.0 == v200.1 {
                                                                    let v726 = constructor_eq(ctx, v2.0, v200.0, v166.1);
                                                                    // Rule at src/opts/bitops.isle line 305.
                                                                    returns.extend(Some(v726));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    let v729 = constructor_eq(ctx, v2.0, v166.1, v200.0);
                                                                    // Rule at src/opts/bitops.isle line 308.
                                                                    returns.extend(Some(v729));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v166.1 == v200.0 {
                                                                    let v727 = constructor_eq(ctx, v2.0, v166.0, v200.1);
                                                                    // Rule at src/opts/bitops.isle line 306.
                                                                    returns.extend(Some(v727));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    let v728 = constructor_eq(ctx, v2.0, v200.1, v166.0);
                                                                    // Rule at src/opts/bitops.isle line 307.
                                                                    returns.extend(Some(v728));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v166.1 == v200.1 {
                                                                    let v724 = constructor_eq(ctx, v2.0, v200.0, v166.0);
                                                                    // Rule at src/opts/bitops.isle line 303.
                                                                    returns.extend(Some(v724));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    let v725 = constructor_eq(ctx, v2.0, v166.0, v200.0);
                                                                    // Rule at src/opts/bitops.isle line 304.
                                                                    returns.extend(Some(v725));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                    &InstructionData::Ternary {
                                        opcode: ref v1525,
                                        args: ref v1526,
                                    } => {
                                        if let &Opcode::Select = v1525 {
                                            let mut v160 = C::inst_data_value_etor_returns::default();
                                            C::inst_data_value_etor(ctx, v150.1, &mut v160);
                                            let mut v160 = v160.into_context_iter();
                                            while let Some(v161) = v160.next(ctx) {
                                                if let &InstructionData::UnaryImm {
                                                    opcode: ref v210,
                                                    imm: v211,
                                                } = &v161.1 {
                                                    if let &Opcode::Iconst = v210 {
                                                        let v1527 = C::unpack_value_array_3(ctx, v1526);
                                                        let mut v1580 = C::inst_data_value_etor_returns::default();
                                                        C::inst_data_value_etor(ctx, v1527.1, &mut v1580);
                                                        let mut v1580 = v1580.into_context_iter();
                                                        while let Some(v1581) = v1580.next(ctx) {
                                                            if let &InstructionData::UnaryImm {
                                                                opcode: ref v1584,
                                                                imm: v1585,
                                                            } = &v1581.1 {
                                                                if let &Opcode::Iconst = v1584 {
                                                                    let mut v1587 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v1527.2, &mut v1587);
                                                                    let mut v1587 = v1587.into_context_iter();
                                                                    while let Some(v1588) = v1587.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v1591,
                                                                            imm: v1592,
                                                                        } = &v1588.1 {
                                                                            if let &Opcode::Iconst = v1591 {
                                                                                let v1586 = C::u64_from_imm64(ctx, v1585);
                                                                                let v1593 = C::u64_from_imm64(ctx, v1592);
                                                                                let v1594 = C::u64_eq(ctx, v1586, v1593);
                                                                                if v1594 == false {
                                                                                    let v212 = C::u64_from_imm64(ctx, v211);
                                                                                    if v212 == v1586 {
                                                                                        let v1579 = C::value_type(ctx, v1527.0);
                                                                                        let v1595 = constructor_iconst_u(ctx, v1579, 0x0_u64);
                                                                                        let v1596 = constructor_ne(ctx, v154.0, v1527.0, v1595);
                                                                                        // Rule at src/opts/icmp.isle line 385.
                                                                                        returns.extend(Some(v1596));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v212 == v1593 {
                                                                                        let v1579 = C::value_type(ctx, v1527.0);
                                                                                        let v1595 = constructor_iconst_u(ctx, v1579, 0x0_u64);
                                                                                        let v1597 = constructor_eq(ctx, v154.0, v1527.0, v1595);
                                                                                        // Rule at src/opts/icmp.isle line 393.
                                                                                        returns.extend(Some(v1597));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    &InstructionData::Unary {
                                        opcode: ref v299,
                                        arg: v300,
                                    } => {
                                        match v299 {
                                            &Opcode::Ineg => {
                                                if v2.0 == v154.0 {
                                                    let mut v160 = C::inst_data_value_etor_returns::default();
                                                    C::inst_data_value_etor(ctx, v150.1, &mut v160);
                                                    let mut v160 = v160.into_context_iter();
                                                    while let Some(v161) = v160.next(ctx) {
                                                        if let &InstructionData::Unary {
                                                            opcode: ref v301,
                                                            arg: v302,
                                                        } = &v161.1 {
                                                            if let &Opcode::Ineg = v301 {
                                                                if v2.0 == v161.0 {
                                                                    let v303 = constructor_eq(ctx, v2.0, v300, v302);
                                                                    // Rule at src/opts/arithmetic.isle line 406.
                                                                    returns.extend(Some(v303));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            &Opcode::Bnot => {
                                                let mut v160 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v150.1, &mut v160);
                                                let mut v160 = v160.into_context_iter();
                                                while let Some(v161) = v160.next(ctx) {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v164,
                                                        args: ref v165,
                                                    } = &v161.1 {
                                                        if let &Opcode::Band = v164 {
                                                            if v154.0 == v161.0 {
                                                                let v166 = C::unpack_value_array_2(ctx, v165);
                                                                let mut v169 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v166.1, &mut v169);
                                                                let mut v169 = v169.into_context_iter();
                                                                while let Some(v170) = v169.next(ctx) {
                                                                    if let &InstructionData::Unary {
                                                                        opcode: ref v940,
                                                                        arg: v941,
                                                                    } = &v170.1 {
                                                                        if let &Opcode::Bnot = v940 {
                                                                            if v300 == v941 {
                                                                                if v154.0 == v170.0 {
                                                                                    let v942 = constructor_bor(ctx, v154.0, v300, v166.0);
                                                                                    let v930 = constructor_iconst_s(ctx, v154.0, -1_i64);
                                                                                    let v943 = constructor_eq(ctx, v2.0, v942, v930);
                                                                                    // Rule at src/opts/bitops.isle line 694.
                                                                                    returns.extend(Some(v943));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                let mut v184 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v166.0, &mut v184);
                                                                let mut v184 = v184.into_context_iter();
                                                                while let Some(v185) = v184.next(ctx) {
                                                                    if let &InstructionData::Unary {
                                                                        opcode: ref v936,
                                                                        arg: v937,
                                                                    } = &v185.1 {
                                                                        if let &Opcode::Bnot = v936 {
                                                                            if v300 == v937 {
                                                                                if v154.0 == v185.0 {
                                                                                    let v938 = constructor_bor(ctx, v154.0, v300, v166.1);
                                                                                    let v930 = constructor_iconst_s(ctx, v154.0, -1_i64);
                                                                                    let v939 = constructor_eq(ctx, v2.0, v938, v930);
                                                                                    // Rule at src/opts/bitops.isle line 693.
                                                                                    returns.extend(Some(v939));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            &Opcode::Clz => {
                                                let mut v160 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v150.1, &mut v160);
                                                let mut v160 = v160.into_context_iter();
                                                while let Some(v161) = v160.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v210,
                                                        imm: v211,
                                                    } = &v161.1 {
                                                        if let &Opcode::Iconst = v210 {
                                                            let v212 = C::u64_from_imm64(ctx, v211);
                                                            if v212 == 0x0_u64 {
                                                                let v291 = constructor_iconst_u(ctx, v154.0, 0x0_u64);
                                                                let v1603 = constructor_slt(ctx, v2.0, v300, v291);
                                                                // Rule at src/opts/icmp.isle line 446.
                                                                returns.extend(Some(v1603));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            &Opcode::Ctz => {
                                                let mut v160 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v150.1, &mut v160);
                                                let mut v160 = v160.into_context_iter();
                                                while let Some(v161) = v160.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v210,
                                                        imm: v211,
                                                    } = &v161.1 {
                                                        if let &Opcode::Iconst = v210 {
                                                            let v212 = C::u64_from_imm64(ctx, v211);
                                                            if v212 == 0x0_u64 {
                                                                let v1598 = constructor_iconst_u(ctx, v154.0, 0x1_u64);
                                                                let v1599 = constructor_band(ctx, v154.0, v300, v1598);
                                                                let v1600 = constructor_iconst_u(ctx, v154.0, 0x0_u64);
                                                                let v1601 = constructor_ne(ctx, v2.0, v1599, v1600);
                                                                // Rule at src/opts/icmp.isle line 437.
                                                                returns.extend(Some(v1601));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            &Opcode::Sextend => {
                                                let mut v1352 = C::inst_data_value_tupled_etor_returns::default();
                                                C::inst_data_value_tupled_etor(ctx, v150.1, &mut v1352);
                                                let mut v1352 = v1352.into_context_iter();
                                                while let Some(v1353) = v1352.next(ctx) {
                                                    let v1354 = C::iconst_sextend_etor(ctx, v1353);
                                                    if let Some(v1355) = v1354 {
                                                        if v1355.1 == 0_i64 {
                                                            let v1348 = C::value_type(ctx, v300);
                                                            let v1359 = constructor_iconst_s(ctx, v1348, 0_i64);
                                                            let v1360 = constructor_eq(ctx, v1348, v300, v1359);
                                                            // Rule at src/opts/extends.isle line 39.
                                                            returns.extend(Some(v1360));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                    &InstructionData::UnaryImm {
                                        opcode: ref v157,
                                        imm: v158,
                                    } => {
                                        if let &Opcode::Iconst = v157 {
                                            let mut v160 = C::inst_data_value_etor_returns::default();
                                            C::inst_data_value_etor(ctx, v150.1, &mut v160);
                                            let mut v160 = v160.into_context_iter();
                                            while let Some(v161) = v160.next(ctx) {
                                                if let &InstructionData::Binary {
                                                    opcode: ref v164,
                                                    args: ref v165,
                                                } = &v161.1 {
                                                    if let &Opcode::Imul = v164 {
                                                        if v154.0 == v161.0 {
                                                            let v166 = C::unpack_value_array_2(ctx, v165);
                                                            let mut v169 = C::inst_data_value_etor_returns::default();
                                                            C::inst_data_value_etor(ctx, v166.1, &mut v169);
                                                            let mut v169 = v169.into_context_iter();
                                                            while let Some(v170) = v169.next(ctx) {
                                                                if let &InstructionData::UnaryImm {
                                                                    opcode: ref v173,
                                                                    imm: v174,
                                                                } = &v170.1 {
                                                                    if let &Opcode::Iconst = v173 {
                                                                        let v159 = C::u64_from_imm64(ctx, v158);
                                                                        let v175 = C::u64_from_imm64(ctx, v174);
                                                                        let v176 = C::u64_checked_rem(ctx, v159, v175);
                                                                        if let Some(v177) = v176 {
                                                                            if v177 == 0x0_u64 {
                                                                                let v179 = C::u64_rem(ctx, v175, 0x2_u64);
                                                                                if v179 == 0x1_u64 {
                                                                                    if v154.0 == v170.0 {
                                                                                        let v180 = C::u64_div(ctx, v159, v175);
                                                                                        let v181 = C::imm64(ctx, v180);
                                                                                        let v182 = constructor_iconst(ctx, v154.0, v181);
                                                                                        let v234 = constructor_eq(ctx, v2.0, v166.0, v182);
                                                                                        // Rule at src/opts/arithmetic.isle line 272.
                                                                                        returns.extend(Some(v234));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            let mut v184 = C::inst_data_value_etor_returns::default();
                                                            C::inst_data_value_etor(ctx, v166.0, &mut v184);
                                                            let mut v184 = v184.into_context_iter();
                                                            while let Some(v185) = v184.next(ctx) {
                                                                if let &InstructionData::UnaryImm {
                                                                    opcode: ref v188,
                                                                    imm: v189,
                                                                } = &v185.1 {
                                                                    if let &Opcode::Iconst = v188 {
                                                                        let v159 = C::u64_from_imm64(ctx, v158);
                                                                        let v190 = C::u64_from_imm64(ctx, v189);
                                                                        let v191 = C::u64_checked_rem(ctx, v159, v190);
                                                                        if let Some(v192) = v191 {
                                                                            if v192 == 0x0_u64 {
                                                                                let v193 = C::u64_rem(ctx, v190, 0x2_u64);
                                                                                if v193 == 0x1_u64 {
                                                                                    if v154.0 == v185.0 {
                                                                                        let v194 = C::u64_div(ctx, v159, v190);
                                                                                        let v195 = C::imm64(ctx, v194);
                                                                                        let v196 = constructor_iconst(ctx, v154.0, v195);
                                                                                        let v235 = constructor_eq(ctx, v2.0, v166.1, v196);
                                                                                        // Rule at src/opts/arithmetic.isle line 277.
                                                                                        returns.extend(Some(v235));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                            let mut v160 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v150.1, &mut v160);
                            let mut v160 = v160.into_context_iter();
                            while let Some(v161) = v160.next(ctx) {
                                match &v161.1 {
                                    &InstructionData::Binary {
                                        opcode: ref v164,
                                        args: ref v165,
                                    } => {
                                        match v164 {
                                            &Opcode::Iadd => {
                                                let v166 = C::unpack_value_array_2(ctx, v165);
                                                if v150.0 == v166.0 {
                                                    let v293 = constructor_iconst_u(ctx, v161.0, 0x0_u64);
                                                    let v296 = constructor_eq(ctx, v2.0, v166.1, v293);
                                                    // Rule at src/opts/arithmetic.isle line 403.
                                                    returns.extend(Some(v296));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v150.0 == v166.1 {
                                                    let v293 = constructor_iconst_u(ctx, v161.0, 0x0_u64);
                                                    let v298 = constructor_eq(ctx, v2.0, v166.0, v293);
                                                    // Rule at src/opts/arithmetic.isle line 402.
                                                    returns.extend(Some(v298));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                            &Opcode::Isub => {
                                                let v166 = C::unpack_value_array_2(ctx, v165);
                                                if v150.0 == v166.0 {
                                                    let v293 = constructor_iconst_u(ctx, v161.0, 0x0_u64);
                                                    let v296 = constructor_eq(ctx, v2.0, v166.1, v293);
                                                    // Rule at src/opts/arithmetic.isle line 397.
                                                    returns.extend(Some(v296));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                            &Opcode::Bxor => {
                                                let v1516 = C::ty_int(ctx, v161.0);
                                                if let Some(v1517) = v1516 {
                                                    let v166 = C::unpack_value_array_2(ctx, v165);
                                                    if v150.0 == v166.0 {
                                                        let v1518 = constructor_iconst_u(ctx, v1517, 0x0_u64);
                                                        let v1519 = constructor_eq(ctx, v2.0, v166.1, v1518);
                                                        let v1520 = C::subsume(ctx, v1519);
                                                        // Rule at src/opts/icmp.isle line 294.
                                                        returns.extend(Some(v1520));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                    &InstructionData::UnaryImm {
                                        opcode: ref v210,
                                        imm: v211,
                                    } => {
                                        if let &Opcode::Iconst = v210 {
                                            let v212 = C::u64_from_imm64(ctx, v211);
                                            match v212 {
                                                0x0_u64 => {
                                                    let mut v1409 = C::uextend_maybe_etor_returns::default();
                                                    C::uextend_maybe_etor(ctx, v150.0, &mut v1409);
                                                    let mut v1409 = v1409.into_context_iter();
                                                    while let Some(v1410) = v1409.next(ctx) {
                                                        let mut v1413 = C::inst_data_value_etor_returns::default();
                                                        C::inst_data_value_etor(ctx, v1410.1, &mut v1413);
                                                        let mut v1413 = v1413.into_context_iter();
                                                        while let Some(v1414) = v1413.next(ctx) {
                                                            if let &InstructionData::IntCompare {
                                                                opcode: ref v1417,
                                                                args: ref v1418,
                                                                cond: ref v1419,
                                                            } = &v1414.1 {
                                                                if let &Opcode::Icmp = v1417 {
                                                                    if v2.0 == v1414.0 {
                                                                        let v1430 = &C::intcc_complement(ctx, v1419);
                                                                        let v1420 = C::unpack_value_array_2(ctx, v1418);
                                                                        let v1431 = constructor_icmp(ctx, v2.0, v1430, v1420.0, v1420.1);
                                                                        let v1432 = C::subsume(ctx, v1431);
                                                                        // Rule at src/opts/icmp.isle line 62.
                                                                        returns.extend(Some(v1432));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                0x1_u64 => {
                                                    let mut v1409 = C::uextend_maybe_etor_returns::default();
                                                    C::uextend_maybe_etor(ctx, v150.0, &mut v1409);
                                                    let mut v1409 = v1409.into_context_iter();
                                                    while let Some(v1410) = v1409.next(ctx) {
                                                        let mut v1413 = C::inst_data_value_etor_returns::default();
                                                        C::inst_data_value_etor(ctx, v1410.1, &mut v1413);
                                                        let mut v1413 = v1413.into_context_iter();
                                                        while let Some(v1414) = v1413.next(ctx) {
                                                            if let &InstructionData::IntCompare {
                                                                opcode: ref v1417,
                                                                args: ref v1418,
                                                                cond: ref v1419,
                                                            } = &v1414.1 {
                                                                if let &Opcode::Icmp = v1417 {
                                                                    let v1423 = C::subsume(ctx, v1410.1);
                                                                    // Rule at src/opts/icmp.isle line 76.
                                                                    returns.extend(Some(v1423));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                _ => {}
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                            if v150.0 == v150.1 {
                                let v339 = C::ty_int(ctx, v2.0);
                                if let Some(v340) = v339 {
                                    let v1395 = constructor_iconst_u(ctx, v340, 0x1_u64);
                                    let v1396 = C::subsume(ctx, v1395);
                                    // Rule at src/opts/icmp.isle line 4.
                                    returns.extend(Some(v1396));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                        }
                        &IntCC::NotEqual => {
                            let v150 = C::unpack_value_array_2(ctx, v148);
                            let mut v153 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v150.0, &mut v153);
                            let mut v153 = v153.into_context_iter();
                            while let Some(v154) = v153.next(ctx) {
                                match &v154.1 {
                                    &InstructionData::Binary {
                                        opcode: ref v198,
                                        args: ref v199,
                                    } => {
                                        match v198 {
                                            &Opcode::Iadd => {
                                                let mut v160 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v150.1, &mut v160);
                                                let mut v160 = v160.into_context_iter();
                                                while let Some(v161) = v160.next(ctx) {
                                                    match &v161.1 {
                                                        &InstructionData::Binary {
                                                            opcode: ref v164,
                                                            args: ref v165,
                                                        } => {
                                                            if let &Opcode::Iadd = v164 {
                                                                let v166 = C::unpack_value_array_2(ctx, v165);
                                                                let v200 = C::unpack_value_array_2(ctx, v199);
                                                                if v166.0 == v200.0 {
                                                                    let v822 = constructor_ne(ctx, v2.0, v200.1, v166.1);
                                                                    let v1404 = C::subsume(ctx, v822);
                                                                    // Rule at src/opts/icmp.isle line 34.
                                                                    returns.extend(Some(v1404));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v166.0 == v200.1 {
                                                                    let v818 = constructor_ne(ctx, v2.0, v200.0, v166.1);
                                                                    let v1402 = C::subsume(ctx, v818);
                                                                    // Rule at src/opts/icmp.isle line 30.
                                                                    returns.extend(Some(v1402));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v166.1 == v200.0 {
                                                                    let v820 = constructor_ne(ctx, v2.0, v200.1, v166.0);
                                                                    let v1403 = C::subsume(ctx, v820);
                                                                    // Rule at src/opts/icmp.isle line 32.
                                                                    returns.extend(Some(v1403));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v166.1 == v200.1 {
                                                                    let v816 = constructor_ne(ctx, v2.0, v200.0, v166.0);
                                                                    let v1401 = C::subsume(ctx, v816);
                                                                    // Rule at src/opts/icmp.isle line 28.
                                                                    returns.extend(Some(v1401));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                let mut v169 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v166.1, &mut v169);
                                                                let mut v169 = v169.into_context_iter();
                                                                while let Some(v170) = v169.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v173,
                                                                        imm: v174,
                                                                    } = &v170.1 {
                                                                        if let &Opcode::Iconst = v173 {
                                                                            let mut v203 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v200.1, &mut v203);
                                                                            let mut v203 = v203.into_context_iter();
                                                                            while let Some(v204) = v203.next(ctx) {
                                                                                if let &InstructionData::UnaryImm {
                                                                                    opcode: ref v207,
                                                                                    imm: v208,
                                                                                } = &v204.1 {
                                                                                    if let &Opcode::Iconst = v207 {
                                                                                        let v1078 = constructor_isub(ctx, v161.0, v166.1, v200.1);
                                                                                        let v1079 = constructor_iadd(ctx, v154.0, v166.0, v1078);
                                                                                        let v1081 = constructor_ne(ctx, v2.0, v200.0, v1079);
                                                                                        // Rule at src/opts/cprop.isle line 258.
                                                                                        returns.extend(Some(v1081));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::UnaryImm {
                                                            opcode: ref v210,
                                                            imm: v211,
                                                        } => {
                                                            if let &Opcode::Iconst = v210 {
                                                                let v200 = C::unpack_value_array_2(ctx, v199);
                                                                let mut v203 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v200.1, &mut v203);
                                                                let mut v203 = v203.into_context_iter();
                                                                while let Some(v204) = v203.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v207,
                                                                        imm: v208,
                                                                    } = &v204.1 {
                                                                        if let &Opcode::Iconst = v207 {
                                                                            let v1072 = constructor_isub(ctx, v154.0, v150.1, v200.1);
                                                                            let v1074 = constructor_ne(ctx, v2.0, v200.0, v1072);
                                                                            // Rule at src/opts/cprop.isle line 248.
                                                                            returns.extend(Some(v1074));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                            }
                                            &Opcode::Isub => {
                                                let v200 = C::unpack_value_array_2(ctx, v199);
                                                let mut v203 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v200.1, &mut v203);
                                                let mut v203 = v203.into_context_iter();
                                                while let Some(v204) = v203.next(ctx) {
                                                    match &v204.1 {
                                                        &InstructionData::IntCompare {
                                                            opcode: ref v1965,
                                                            args: ref v1966,
                                                            cond: ref v1967,
                                                        } => {
                                                            if let &Opcode::Icmp = v1965 {
                                                                match v1967 {
                                                                    &IntCC::SignedLessThan => {
                                                                        if v154.0 == I8 {
                                                                            let mut v220 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v200.0, &mut v220);
                                                                            let mut v220 = v220.into_context_iter();
                                                                            while let Some(v221) = v220.next(ctx) {
                                                                                if let &InstructionData::IntCompare {
                                                                                    opcode: ref v1959,
                                                                                    args: ref v1960,
                                                                                    cond: ref v1961,
                                                                                } = &v221.1 {
                                                                                    if let &Opcode::Icmp = v1959 {
                                                                                        if let &IntCC::SignedGreaterThan = v1961 {
                                                                                            if v204.0 == v221.0 {
                                                                                                let v1962 = C::unpack_value_array_2(ctx, v1960);
                                                                                                let v1968 = C::unpack_value_array_2(ctx, v1966);
                                                                                                if v1962.0 == v1968.0 {
                                                                                                    if v1962.1 == v1968.1 {
                                                                                                        let mut v1352 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                        C::inst_data_value_tupled_etor(ctx, v150.1, &mut v1352);
                                                                                                        let mut v1352 = v1352.into_context_iter();
                                                                                                        while let Some(v1353) = v1352.next(ctx) {
                                                                                                            let v1354 = C::iconst_sextend_etor(ctx, v1353);
                                                                                                            if let Some(v1355) = v1354 {
                                                                                                                match v1355.1 {
                                                                                                                    -1_i64 => {
                                                                                                                        let v1979 = constructor_sge(ctx, v221.0, v1962.0, v1962.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 182.
                                                                                                                        returns.extend(Some(v1979));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                    0_i64 => {
                                                                                                                        let v1972 = constructor_ne(ctx, v221.0, v1962.0, v1962.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 150.
                                                                                                                        returns.extend(Some(v1972));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                    1_i64 => {
                                                                                                                        let v1975 = constructor_sle(ctx, v221.0, v1962.0, v1962.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 190.
                                                                                                                        returns.extend(Some(v1975));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                    _ => {}
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        if v154.0 == I8 {
                                                                            let mut v220 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v200.0, &mut v220);
                                                                            let mut v220 = v220.into_context_iter();
                                                                            while let Some(v221) = v220.next(ctx) {
                                                                                if let &InstructionData::IntCompare {
                                                                                    opcode: ref v1959,
                                                                                    args: ref v1960,
                                                                                    cond: ref v1961,
                                                                                } = &v221.1 {
                                                                                    if let &Opcode::Icmp = v1959 {
                                                                                        if let &IntCC::UnsignedGreaterThan = v1961 {
                                                                                            if v204.0 == v221.0 {
                                                                                                let v1962 = C::unpack_value_array_2(ctx, v1960);
                                                                                                let v1968 = C::unpack_value_array_2(ctx, v1966);
                                                                                                if v1962.0 == v1968.0 {
                                                                                                    if v1962.1 == v1968.1 {
                                                                                                        let mut v1352 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                        C::inst_data_value_tupled_etor(ctx, v150.1, &mut v1352);
                                                                                                        let mut v1352 = v1352.into_context_iter();
                                                                                                        while let Some(v1353) = v1352.next(ctx) {
                                                                                                            let v1354 = C::iconst_sextend_etor(ctx, v1353);
                                                                                                            if let Some(v1355) = v1354 {
                                                                                                                match v1355.1 {
                                                                                                                    -1_i64 => {
                                                                                                                        let v1980 = constructor_uge(ctx, v221.0, v1962.0, v1962.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 184.
                                                                                                                        returns.extend(Some(v1980));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                    0_i64 => {
                                                                                                                        let v1972 = constructor_ne(ctx, v221.0, v1962.0, v1962.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 152.
                                                                                                                        returns.extend(Some(v1972));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                    1_i64 => {
                                                                                                                        let v1976 = constructor_ule(ctx, v221.0, v1962.0, v1962.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 192.
                                                                                                                        returns.extend(Some(v1976));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                    _ => {}
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::UnaryImm {
                                                            opcode: ref v207,
                                                            imm: v208,
                                                        } => {
                                                            if let &Opcode::Iconst = v207 {
                                                                let mut v160 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v150.1, &mut v160);
                                                                let mut v160 = v160.into_context_iter();
                                                                while let Some(v161) = v160.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v210,
                                                                        imm: v211,
                                                                    } = &v161.1 {
                                                                        if let &Opcode::Iconst = v210 {
                                                                            let v1075 = constructor_iadd(ctx, v154.0, v150.1, v200.1);
                                                                            let v1077 = constructor_ne(ctx, v2.0, v200.0, v1075);
                                                                            // Rule at src/opts/cprop.isle line 253.
                                                                            returns.extend(Some(v1077));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                if v150.1 == v200.0 {
                                                    let v291 = constructor_iconst_u(ctx, v154.0, 0x0_u64);
                                                    let v292 = constructor_ne(ctx, v2.0, v200.1, v291);
                                                    // Rule at src/opts/arithmetic.isle line 392.
                                                    returns.extend(Some(v292));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let mut v160 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v150.1, &mut v160);
                                                let mut v160 = v160.into_context_iter();
                                                while let Some(v161) = v160.next(ctx) {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v164,
                                                        args: ref v165,
                                                    } = &v161.1 {
                                                        if let &Opcode::Isub = v164 {
                                                            let v166 = C::unpack_value_array_2(ctx, v165);
                                                            let v1405 = constructor_iadd(ctx, v154.0, v200.0, v166.1);
                                                            let v1406 = constructor_iadd(ctx, v161.0, v166.0, v200.1);
                                                            let v1408 = constructor_ne(ctx, v2.0, v1405, v1406);
                                                            // Rule at src/opts/icmp.isle line 42.
                                                            returns.extend(Some(v1408));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                            }
                                            &Opcode::Imul => {
                                                let mut v160 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v150.1, &mut v160);
                                                let mut v160 = v160.into_context_iter();
                                                while let Some(v161) = v160.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v210,
                                                        imm: v211,
                                                    } = &v161.1 {
                                                        if let &Opcode::Iconst = v210 {
                                                            if v154.0 == v161.0 {
                                                                let v200 = C::unpack_value_array_2(ctx, v199);
                                                                let mut v203 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v200.1, &mut v203);
                                                                let mut v203 = v203.into_context_iter();
                                                                while let Some(v204) = v203.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v207,
                                                                        imm: v208,
                                                                    } = &v204.1 {
                                                                        if let &Opcode::Iconst = v207 {
                                                                            let v212 = C::u64_from_imm64(ctx, v211);
                                                                            let v209 = C::u64_from_imm64(ctx, v208);
                                                                            let v213 = C::u64_checked_rem(ctx, v212, v209);
                                                                            if let Some(v214) = v213 {
                                                                                if v214 == 0x0_u64 {
                                                                                    let v215 = C::u64_rem(ctx, v209, 0x2_u64);
                                                                                    if v215 == 0x1_u64 {
                                                                                        if v154.0 == v204.0 {
                                                                                            let v216 = C::u64_div(ctx, v212, v209);
                                                                                            let v217 = C::imm64(ctx, v216);
                                                                                            let v218 = constructor_iconst(ctx, v154.0, v217);
                                                                                            let v219 = constructor_ne(ctx, v2.0, v200.0, v218);
                                                                                            // Rule at src/opts/arithmetic.isle line 260.
                                                                                            returns.extend(Some(v219));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                let mut v220 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v200.0, &mut v220);
                                                                let mut v220 = v220.into_context_iter();
                                                                while let Some(v221) = v220.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v224,
                                                                        imm: v225,
                                                                    } = &v221.1 {
                                                                        if let &Opcode::Iconst = v224 {
                                                                            let v212 = C::u64_from_imm64(ctx, v211);
                                                                            let v226 = C::u64_from_imm64(ctx, v225);
                                                                            let v227 = C::u64_checked_rem(ctx, v212, v226);
                                                                            if let Some(v228) = v227 {
                                                                                if v228 == 0x0_u64 {
                                                                                    let v229 = C::u64_rem(ctx, v226, 0x2_u64);
                                                                                    if v229 == 0x1_u64 {
                                                                                        if v154.0 == v221.0 {
                                                                                            let v230 = C::u64_div(ctx, v212, v226);
                                                                                            let v231 = C::imm64(ctx, v230);
                                                                                            let v232 = constructor_iconst(ctx, v154.0, v231);
                                                                                            let v233 = constructor_ne(ctx, v2.0, v200.1, v232);
                                                                                            // Rule at src/opts/arithmetic.isle line 265.
                                                                                            returns.extend(Some(v233));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            &Opcode::Bxor => {
                                                let mut v160 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v150.1, &mut v160);
                                                let mut v160 = v160.into_context_iter();
                                                while let Some(v161) = v160.next(ctx) {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v164,
                                                        args: ref v165,
                                                    } = &v161.1 {
                                                        if let &Opcode::Bxor = v164 {
                                                            if v154.0 == v161.0 {
                                                                let v166 = C::unpack_value_array_2(ctx, v165);
                                                                let v200 = C::unpack_value_array_2(ctx, v199);
                                                                if v166.0 == v200.0 {
                                                                    let v822 = constructor_ne(ctx, v2.0, v200.1, v166.1);
                                                                    // Rule at src/opts/bitops.isle line 460.
                                                                    returns.extend(Some(v822));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    let v823 = constructor_ne(ctx, v2.0, v166.1, v200.1);
                                                                    // Rule at src/opts/bitops.isle line 461.
                                                                    returns.extend(Some(v823));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v166.0 == v200.1 {
                                                                    let v818 = constructor_ne(ctx, v2.0, v200.0, v166.1);
                                                                    // Rule at src/opts/bitops.isle line 456.
                                                                    returns.extend(Some(v818));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    let v821 = constructor_ne(ctx, v2.0, v166.1, v200.0);
                                                                    // Rule at src/opts/bitops.isle line 459.
                                                                    returns.extend(Some(v821));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v166.1 == v200.0 {
                                                                    let v819 = constructor_ne(ctx, v2.0, v166.0, v200.1);
                                                                    // Rule at src/opts/bitops.isle line 457.
                                                                    returns.extend(Some(v819));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    let v820 = constructor_ne(ctx, v2.0, v200.1, v166.0);
                                                                    // Rule at src/opts/bitops.isle line 458.
                                                                    returns.extend(Some(v820));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v166.1 == v200.1 {
                                                                    let v816 = constructor_ne(ctx, v2.0, v200.0, v166.0);
                                                                    // Rule at src/opts/bitops.isle line 454.
                                                                    returns.extend(Some(v816));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    let v817 = constructor_ne(ctx, v2.0, v166.0, v200.0);
                                                                    // Rule at src/opts/bitops.isle line 455.
                                                                    returns.extend(Some(v817));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                    &InstructionData::Ternary {
                                        opcode: ref v1525,
                                        args: ref v1526,
                                    } => {
                                        if let &Opcode::Select = v1525 {
                                            let v1527 = C::unpack_value_array_3(ctx, v1526);
                                            if v150.1 == v1527.1 {
                                                let mut v1531 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v1527.0, &mut v1531);
                                                let mut v1531 = v1531.into_context_iter();
                                                while let Some(v1532) = v1531.next(ctx) {
                                                    if let &InstructionData::IntCompare {
                                                        opcode: ref v1535,
                                                        args: ref v1536,
                                                        cond: ref v1537,
                                                    } = &v1532.1 {
                                                        if let &Opcode::Icmp = v1535 {
                                                            match v1537 {
                                                                &IntCC::SignedLessThan => {
                                                                    if v2.0 == v1532.0 {
                                                                        let v1538 = C::unpack_value_array_2(ctx, v1536);
                                                                        if v150.1 == v1538.0 {
                                                                            if v1527.2 == v1538.1 {
                                                                                let v1541 = constructor_sgt(ctx, v2.0, v1538.0, v1538.1);
                                                                                // Rule at src/opts/icmp.isle line 302.
                                                                                returns.extend(Some(v1541));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &IntCC::UnsignedLessThan => {
                                                                    if v2.0 == v1532.0 {
                                                                        let v1538 = C::unpack_value_array_2(ctx, v1536);
                                                                        if v150.1 == v1538.0 {
                                                                            if v1527.2 == v1538.1 {
                                                                                let v1542 = constructor_ugt(ctx, v2.0, v1538.0, v1538.1);
                                                                                // Rule at src/opts/icmp.isle line 303.
                                                                                returns.extend(Some(v1542));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            let mut v160 = C::inst_data_value_etor_returns::default();
                                            C::inst_data_value_etor(ctx, v150.1, &mut v160);
                                            let mut v160 = v160.into_context_iter();
                                            while let Some(v161) = v160.next(ctx) {
                                                if let &InstructionData::UnaryImm {
                                                    opcode: ref v210,
                                                    imm: v211,
                                                } = &v161.1 {
                                                    if let &Opcode::Iconst = v210 {
                                                        let mut v1580 = C::inst_data_value_etor_returns::default();
                                                        C::inst_data_value_etor(ctx, v1527.1, &mut v1580);
                                                        let mut v1580 = v1580.into_context_iter();
                                                        while let Some(v1581) = v1580.next(ctx) {
                                                            if let &InstructionData::UnaryImm {
                                                                opcode: ref v1584,
                                                                imm: v1585,
                                                            } = &v1581.1 {
                                                                if let &Opcode::Iconst = v1584 {
                                                                    let mut v1587 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v1527.2, &mut v1587);
                                                                    let mut v1587 = v1587.into_context_iter();
                                                                    while let Some(v1588) = v1587.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v1591,
                                                                            imm: v1592,
                                                                        } = &v1588.1 {
                                                                            if let &Opcode::Iconst = v1591 {
                                                                                let v1586 = C::u64_from_imm64(ctx, v1585);
                                                                                let v1593 = C::u64_from_imm64(ctx, v1592);
                                                                                let v1594 = C::u64_eq(ctx, v1586, v1593);
                                                                                if v1594 == false {
                                                                                    let v212 = C::u64_from_imm64(ctx, v211);
                                                                                    if v212 == v1586 {
                                                                                        let v1579 = C::value_type(ctx, v1527.0);
                                                                                        let v1595 = constructor_iconst_u(ctx, v1579, 0x0_u64);
                                                                                        let v1597 = constructor_eq(ctx, v154.0, v1527.0, v1595);
                                                                                        // Rule at src/opts/icmp.isle line 401.
                                                                                        returns.extend(Some(v1597));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v212 == v1593 {
                                                                                        let v1579 = C::value_type(ctx, v1527.0);
                                                                                        let v1595 = constructor_iconst_u(ctx, v1579, 0x0_u64);
                                                                                        let v1596 = constructor_ne(ctx, v154.0, v1527.0, v1595);
                                                                                        // Rule at src/opts/icmp.isle line 409.
                                                                                        returns.extend(Some(v1596));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    &InstructionData::Unary {
                                        opcode: ref v299,
                                        arg: v300,
                                    } => {
                                        match v299 {
                                            &Opcode::Clz => {
                                                let mut v160 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v150.1, &mut v160);
                                                let mut v160 = v160.into_context_iter();
                                                while let Some(v161) = v160.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v210,
                                                        imm: v211,
                                                    } = &v161.1 {
                                                        if let &Opcode::Iconst = v210 {
                                                            let v212 = C::u64_from_imm64(ctx, v211);
                                                            if v212 == 0x0_u64 {
                                                                let v291 = constructor_iconst_u(ctx, v154.0, 0x0_u64);
                                                                let v1604 = constructor_sge(ctx, v2.0, v300, v291);
                                                                // Rule at src/opts/icmp.isle line 450.
                                                                returns.extend(Some(v1604));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            &Opcode::Ctz => {
                                                let mut v160 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v150.1, &mut v160);
                                                let mut v160 = v160.into_context_iter();
                                                while let Some(v161) = v160.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v210,
                                                        imm: v211,
                                                    } = &v161.1 {
                                                        if let &Opcode::Iconst = v210 {
                                                            let v212 = C::u64_from_imm64(ctx, v211);
                                                            if v212 == 0x0_u64 {
                                                                let v1598 = constructor_iconst_u(ctx, v154.0, 0x1_u64);
                                                                let v1599 = constructor_band(ctx, v154.0, v300, v1598);
                                                                let v1600 = constructor_iconst_u(ctx, v154.0, 0x0_u64);
                                                                let v1602 = constructor_eq(ctx, v2.0, v1599, v1600);
                                                                // Rule at src/opts/icmp.isle line 441.
                                                                returns.extend(Some(v1602));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            &Opcode::Sextend => {
                                                let mut v1352 = C::inst_data_value_tupled_etor_returns::default();
                                                C::inst_data_value_tupled_etor(ctx, v150.1, &mut v1352);
                                                let mut v1352 = v1352.into_context_iter();
                                                while let Some(v1353) = v1352.next(ctx) {
                                                    let v1354 = C::iconst_sextend_etor(ctx, v1353);
                                                    if let Some(v1355) = v1354 {
                                                        if v1355.1 == 0_i64 {
                                                            let v1348 = C::value_type(ctx, v300);
                                                            let v1359 = constructor_iconst_s(ctx, v1348, 0_i64);
                                                            let v1361 = constructor_ne(ctx, v1348, v300, v1359);
                                                            // Rule at src/opts/extends.isle line 41.
                                                            returns.extend(Some(v1361));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                    &InstructionData::UnaryImm {
                                        opcode: ref v157,
                                        imm: v158,
                                    } => {
                                        if let &Opcode::Iconst = v157 {
                                            let mut v160 = C::inst_data_value_etor_returns::default();
                                            C::inst_data_value_etor(ctx, v150.1, &mut v160);
                                            let mut v160 = v160.into_context_iter();
                                            while let Some(v161) = v160.next(ctx) {
                                                if let &InstructionData::Binary {
                                                    opcode: ref v164,
                                                    args: ref v165,
                                                } = &v161.1 {
                                                    if let &Opcode::Imul = v164 {
                                                        if v154.0 == v161.0 {
                                                            let v166 = C::unpack_value_array_2(ctx, v165);
                                                            let mut v169 = C::inst_data_value_etor_returns::default();
                                                            C::inst_data_value_etor(ctx, v166.1, &mut v169);
                                                            let mut v169 = v169.into_context_iter();
                                                            while let Some(v170) = v169.next(ctx) {
                                                                if let &InstructionData::UnaryImm {
                                                                    opcode: ref v173,
                                                                    imm: v174,
                                                                } = &v170.1 {
                                                                    if let &Opcode::Iconst = v173 {
                                                                        let v159 = C::u64_from_imm64(ctx, v158);
                                                                        let v175 = C::u64_from_imm64(ctx, v174);
                                                                        let v176 = C::u64_checked_rem(ctx, v159, v175);
                                                                        if let Some(v177) = v176 {
                                                                            if v177 == 0x0_u64 {
                                                                                let v179 = C::u64_rem(ctx, v175, 0x2_u64);
                                                                                if v179 == 0x1_u64 {
                                                                                    if v154.0 == v170.0 {
                                                                                        let v180 = C::u64_div(ctx, v159, v175);
                                                                                        let v181 = C::imm64(ctx, v180);
                                                                                        let v182 = constructor_iconst(ctx, v154.0, v181);
                                                                                        let v183 = constructor_ne(ctx, v2.0, v166.0, v182);
                                                                                        // Rule at src/opts/arithmetic.isle line 250.
                                                                                        returns.extend(Some(v183));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            let mut v184 = C::inst_data_value_etor_returns::default();
                                                            C::inst_data_value_etor(ctx, v166.0, &mut v184);
                                                            let mut v184 = v184.into_context_iter();
                                                            while let Some(v185) = v184.next(ctx) {
                                                                if let &InstructionData::UnaryImm {
                                                                    opcode: ref v188,
                                                                    imm: v189,
                                                                } = &v185.1 {
                                                                    if let &Opcode::Iconst = v188 {
                                                                        let v159 = C::u64_from_imm64(ctx, v158);
                                                                        let v190 = C::u64_from_imm64(ctx, v189);
                                                                        let v191 = C::u64_checked_rem(ctx, v159, v190);
                                                                        if let Some(v192) = v191 {
                                                                            if v192 == 0x0_u64 {
                                                                                let v193 = C::u64_rem(ctx, v190, 0x2_u64);
                                                                                if v193 == 0x1_u64 {
                                                                                    if v154.0 == v185.0 {
                                                                                        let v194 = C::u64_div(ctx, v159, v190);
                                                                                        let v195 = C::imm64(ctx, v194);
                                                                                        let v196 = constructor_iconst(ctx, v154.0, v195);
                                                                                        let v197 = constructor_ne(ctx, v2.0, v166.1, v196);
                                                                                        // Rule at src/opts/arithmetic.isle line 255.
                                                                                        returns.extend(Some(v197));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                            let mut v160 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v150.1, &mut v160);
                            let mut v160 = v160.into_context_iter();
                            while let Some(v161) = v160.next(ctx) {
                                match &v161.1 {
                                    &InstructionData::Binary {
                                        opcode: ref v164,
                                        args: ref v165,
                                    } => {
                                        match v164 {
                                            &Opcode::Isub => {
                                                let v166 = C::unpack_value_array_2(ctx, v165);
                                                if v150.0 == v166.0 {
                                                    let v293 = constructor_iconst_u(ctx, v161.0, 0x0_u64);
                                                    let v294 = constructor_ne(ctx, v2.0, v166.1, v293);
                                                    // Rule at src/opts/arithmetic.isle line 393.
                                                    returns.extend(Some(v294));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                            &Opcode::Bxor => {
                                                let v1516 = C::ty_int(ctx, v161.0);
                                                if let Some(v1517) = v1516 {
                                                    let v166 = C::unpack_value_array_2(ctx, v165);
                                                    if v150.0 == v166.0 {
                                                        let v1518 = constructor_iconst_u(ctx, v1517, 0x0_u64);
                                                        let v1521 = constructor_ne(ctx, v2.0, v166.1, v1518);
                                                        let v1522 = C::subsume(ctx, v1521);
                                                        // Rule at src/opts/icmp.isle line 295.
                                                        returns.extend(Some(v1522));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                    &InstructionData::UnaryImm {
                                        opcode: ref v210,
                                        imm: v211,
                                    } => {
                                        if let &Opcode::Iconst = v210 {
                                            let v212 = C::u64_from_imm64(ctx, v211);
                                            match v212 {
                                                0x0_u64 => {
                                                    let mut v1409 = C::uextend_maybe_etor_returns::default();
                                                    C::uextend_maybe_etor(ctx, v150.0, &mut v1409);
                                                    let mut v1409 = v1409.into_context_iter();
                                                    while let Some(v1410) = v1409.next(ctx) {
                                                        let mut v1413 = C::inst_data_value_etor_returns::default();
                                                        C::inst_data_value_etor(ctx, v1410.1, &mut v1413);
                                                        let mut v1413 = v1413.into_context_iter();
                                                        while let Some(v1414) = v1413.next(ctx) {
                                                            match &v1414.1 {
                                                                &InstructionData::FloatCompare {
                                                                    opcode: ref v1424,
                                                                    args: ref v1425,
                                                                    cond: ref v1426,
                                                                } => {
                                                                    if let &Opcode::Fcmp = v1424 {
                                                                        if v2.0 == v1414.0 {
                                                                            let v1423 = C::subsume(ctx, v1410.1);
                                                                            // Rule at src/opts/icmp.isle line 55.
                                                                            returns.extend(Some(v1423));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                &InstructionData::IntCompare {
                                                                    opcode: ref v1417,
                                                                    args: ref v1418,
                                                                    cond: ref v1419,
                                                                } => {
                                                                    if let &Opcode::Icmp = v1417 {
                                                                        if v2.0 == v1414.0 {
                                                                            let v1423 = C::subsume(ctx, v1410.1);
                                                                            // Rule at src/opts/icmp.isle line 48.
                                                                            returns.extend(Some(v1423));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                    }
                                                    let mut v376 = ContextIterWrapper::<ConstructorVec<_>, _>::default();
                                                    constructor_truthy(ctx, v150.0, &mut v376);
                                                    let mut v376 = v376.into_context_iter();
                                                    while let Some(v377) = v376.next(ctx) {
                                                        let v378 = C::value_type(ctx, v377);
                                                        let v379 = C::ty_int_ref_scalar_64_extract(ctx, v378);
                                                        if let Some(v380) = v379 {
                                                            let v381 = constructor_iconst_u(ctx, v380, 0x0_u64);
                                                            let v382 = constructor_ne(ctx, v2.0, v377, v381);
                                                            // Rule at src/opts/bitops.isle line 114.
                                                            returns.extend(Some(v382));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                                0x1_u64 => {
                                                    let mut v1409 = C::uextend_maybe_etor_returns::default();
                                                    C::uextend_maybe_etor(ctx, v150.0, &mut v1409);
                                                    let mut v1409 = v1409.into_context_iter();
                                                    while let Some(v1410) = v1409.next(ctx) {
                                                        let mut v1413 = C::inst_data_value_etor_returns::default();
                                                        C::inst_data_value_etor(ctx, v1410.1, &mut v1413);
                                                        let mut v1413 = v1413.into_context_iter();
                                                        while let Some(v1414) = v1413.next(ctx) {
                                                            if let &InstructionData::IntCompare {
                                                                opcode: ref v1417,
                                                                args: ref v1418,
                                                                cond: ref v1419,
                                                            } = &v1414.1 {
                                                                if let &Opcode::Icmp = v1417 {
                                                                    if v2.0 == v1414.0 {
                                                                        let v1430 = &C::intcc_complement(ctx, v1419);
                                                                        let v1420 = C::unpack_value_array_2(ctx, v1418);
                                                                        let v1431 = constructor_icmp(ctx, v2.0, v1430, v1420.0, v1420.1);
                                                                        let v1432 = C::subsume(ctx, v1431);
                                                                        // Rule at src/opts/icmp.isle line 69.
                                                                        returns.extend(Some(v1432));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                _ => {}
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                            if v150.0 == v150.1 {
                                let v339 = C::ty_int(ctx, v2.0);
                                if let Some(v340) = v339 {
                                    let v341 = constructor_iconst_u(ctx, v340, 0x0_u64);
                                    let v342 = C::subsume(ctx, v341);
                                    // Rule at src/opts/icmp.isle line 5.
                                    returns.extend(Some(v342));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                        }
                        &IntCC::SignedGreaterThan => {
                            let v334 = C::fits_in_64(ctx, v2.0);
                            if let Some(v335) = v334 {
                                let v1450 = C::ty_int(ctx, v335);
                                if let Some(v1451) = v1450 {
                                    let v150 = C::unpack_value_array_2(ctx, v148);
                                    let mut v160 = C::inst_data_value_etor_returns::default();
                                    C::inst_data_value_etor(ctx, v150.1, &mut v160);
                                    let mut v160 = v160.into_context_iter();
                                    while let Some(v161) = v160.next(ctx) {
                                        if let &InstructionData::UnaryImm {
                                            opcode: ref v210,
                                            imm: v211,
                                        } = &v161.1 {
                                            if let &Opcode::Iconst = v210 {
                                                let v212 = C::u64_from_imm64(ctx, v211);
                                                let v1461 = C::ty_smin(ctx, v161.0);
                                                let v1462 = C::u64_eq(ctx, v212, v1461);
                                                if v1462 == true {
                                                    let v1453 = constructor_ne(ctx, v1451, v150.0, v150.1);
                                                    // Rule at src/opts/icmp.isle line 149.
                                                    returns.extend(Some(v1453));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let v1463 = C::ty_smax(ctx, v161.0);
                                                let v1464 = C::u64_eq(ctx, v212, v1463);
                                                if v1464 == true {
                                                    let v1459 = constructor_iconst_u(ctx, v1451, 0x0_u64);
                                                    let v1460 = C::subsume(ctx, v1459);
                                                    // Rule at src/opts/icmp.isle line 169.
                                                    returns.extend(Some(v1460));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                                let v150 = C::unpack_value_array_2(ctx, v148);
                                let mut v153 = C::inst_data_value_etor_returns::default();
                                C::inst_data_value_etor(ctx, v150.0, &mut v153);
                                let mut v153 = v153.into_context_iter();
                                while let Some(v154) = v153.next(ctx) {
                                    if let &InstructionData::Binary {
                                        opcode: ref v198,
                                        args: ref v199,
                                    } = &v154.1 {
                                        if let &Opcode::Smin = v198 {
                                            let v200 = C::unpack_value_array_2(ctx, v199);
                                            if v150.1 == v200.0 {
                                                let v1706 = constructor_iconst_u(ctx, v335, 0x0_u64);
                                                // Rule at src/opts/selects.isle line 105.
                                                returns.extend(Some(v1706));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            if v150.1 == v200.1 {
                                                let v1706 = constructor_iconst_u(ctx, v335, 0x0_u64);
                                                // Rule at src/opts/selects.isle line 106.
                                                returns.extend(Some(v1706));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                }
                            }
                            let v150 = C::unpack_value_array_2(ctx, v148);
                            let mut v1352 = C::inst_data_value_tupled_etor_returns::default();
                            C::inst_data_value_tupled_etor(ctx, v150.1, &mut v1352);
                            let mut v1352 = v1352.into_context_iter();
                            while let Some(v1353) = v1352.next(ctx) {
                                let v1354 = C::iconst_sextend_etor(ctx, v1353);
                                if let Some(v1355) = v1354 {
                                    match v1355.1 {
                                        -1_i64 => {
                                            let v1475 = constructor_iconst_s(ctx, v1355.0, 0_i64);
                                            let v1478 = constructor_sge(ctx, v2.0, v150.0, v1475);
                                            // Rule at src/opts/icmp.isle line 201.
                                            returns.extend(Some(v1478));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        0_i64 => {
                                            let mut v153 = C::inst_data_value_etor_returns::default();
                                            C::inst_data_value_etor(ctx, v150.0, &mut v153);
                                            let mut v153 = v153.into_context_iter();
                                            while let Some(v154) = v153.next(ctx) {
                                                if v154.0 == I8 {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v198,
                                                        args: ref v199,
                                                    } = &v154.1 {
                                                        if let &Opcode::Isub = v198 {
                                                            let v200 = C::unpack_value_array_2(ctx, v199);
                                                            let mut v203 = C::inst_data_value_etor_returns::default();
                                                            C::inst_data_value_etor(ctx, v200.1, &mut v203);
                                                            let mut v203 = v203.into_context_iter();
                                                            while let Some(v204) = v203.next(ctx) {
                                                                if let &InstructionData::IntCompare {
                                                                    opcode: ref v1965,
                                                                    args: ref v1966,
                                                                    cond: ref v1967,
                                                                } = &v204.1 {
                                                                    if let &Opcode::Icmp = v1965 {
                                                                        match v1967 {
                                                                            &IntCC::SignedLessThan => {
                                                                                let mut v220 = C::inst_data_value_etor_returns::default();
                                                                                C::inst_data_value_etor(ctx, v200.0, &mut v220);
                                                                                let mut v220 = v220.into_context_iter();
                                                                                while let Some(v221) = v220.next(ctx) {
                                                                                    if let &InstructionData::IntCompare {
                                                                                        opcode: ref v1959,
                                                                                        args: ref v1960,
                                                                                        cond: ref v1961,
                                                                                    } = &v221.1 {
                                                                                        if let &Opcode::Icmp = v1959 {
                                                                                            if let &IntCC::SignedGreaterThan = v1961 {
                                                                                                if v204.0 == v221.0 {
                                                                                                    let v1962 = C::unpack_value_array_2(ctx, v1960);
                                                                                                    let v1968 = C::unpack_value_array_2(ctx, v1966);
                                                                                                    if v1962.0 == v1968.0 {
                                                                                                        if v1962.1 == v1968.1 {
                                                                                                            let v1977 = constructor_sgt(ctx, v221.0, v1962.0, v1962.1);
                                                                                                            // Rule at src/opts/spaceship.isle line 166.
                                                                                                            returns.extend(Some(v1977));
                                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            &IntCC::UnsignedLessThan => {
                                                                                let mut v220 = C::inst_data_value_etor_returns::default();
                                                                                C::inst_data_value_etor(ctx, v200.0, &mut v220);
                                                                                let mut v220 = v220.into_context_iter();
                                                                                while let Some(v221) = v220.next(ctx) {
                                                                                    if let &InstructionData::IntCompare {
                                                                                        opcode: ref v1959,
                                                                                        args: ref v1960,
                                                                                        cond: ref v1961,
                                                                                    } = &v221.1 {
                                                                                        if let &Opcode::Icmp = v1959 {
                                                                                            if let &IntCC::UnsignedGreaterThan = v1961 {
                                                                                                if v204.0 == v221.0 {
                                                                                                    let v1962 = C::unpack_value_array_2(ctx, v1960);
                                                                                                    let v1968 = C::unpack_value_array_2(ctx, v1966);
                                                                                                    if v1962.0 == v1968.0 {
                                                                                                        if v1962.1 == v1968.1 {
                                                                                                            let v1978 = constructor_ugt(ctx, v221.0, v1962.0, v1962.1);
                                                                                                            // Rule at src/opts/spaceship.isle line 168.
                                                                                                            returns.extend(Some(v1978));
                                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            _ => {}
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                            }
                            let mut v160 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v150.1, &mut v160);
                            let mut v160 = v160.into_context_iter();
                            while let Some(v161) = v160.next(ctx) {
                                if let &InstructionData::Binary {
                                    opcode: ref v164,
                                    args: ref v165,
                                } = &v161.1 {
                                    if let &Opcode::Smax = v164 {
                                        if v2.0 == v161.0 {
                                            let v166 = C::unpack_value_array_2(ctx, v165);
                                            if v150.0 == v166.0 {
                                                let v53 = constructor_iconst_u(ctx, v2.0, 0x0_u64);
                                                // Rule at src/opts/arithmetic.isle line 559.
                                                returns.extend(Some(v53));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            if v150.0 == v166.1 {
                                                let v53 = constructor_iconst_u(ctx, v2.0, 0x0_u64);
                                                // Rule at src/opts/arithmetic.isle line 560.
                                                returns.extend(Some(v53));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                }
                            }
                            let v339 = C::ty_int(ctx, v2.0);
                            if let Some(v340) = v339 {
                                if v150.0 == v150.1 {
                                    let v341 = constructor_iconst_u(ctx, v340, 0x0_u64);
                                    let v342 = C::subsume(ctx, v341);
                                    // Rule at src/opts/icmp.isle line 8.
                                    returns.extend(Some(v342));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                        }
                        &IntCC::SignedGreaterThanOrEqual => {
                            let v150 = C::unpack_value_array_2(ctx, v148);
                            let mut v153 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v150.0, &mut v153);
                            let mut v153 = v153.into_context_iter();
                            while let Some(v154) = v153.next(ctx) {
                                match &v154.1 {
                                    &InstructionData::Binary {
                                        opcode: ref v198,
                                        args: ref v199,
                                    } => {
                                        match v198 {
                                            &Opcode::Smax => {
                                                if v2.0 == v154.0 {
                                                    let v200 = C::unpack_value_array_2(ctx, v199);
                                                    if v150.1 == v200.0 {
                                                        let v290 = constructor_cmp_true(ctx, v2.0);
                                                        // Rule at src/opts/arithmetic.isle line 413.
                                                        returns.extend(Some(v290));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                    if v150.1 == v200.1 {
                                                        let v290 = constructor_cmp_true(ctx, v2.0);
                                                        // Rule at src/opts/arithmetic.isle line 414.
                                                        returns.extend(Some(v290));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &Opcode::Isub => {
                                                if v154.0 == I8 {
                                                    let v200 = C::unpack_value_array_2(ctx, v199);
                                                    let mut v203 = C::inst_data_value_etor_returns::default();
                                                    C::inst_data_value_etor(ctx, v200.1, &mut v203);
                                                    let mut v203 = v203.into_context_iter();
                                                    while let Some(v204) = v203.next(ctx) {
                                                        if let &InstructionData::IntCompare {
                                                            opcode: ref v1965,
                                                            args: ref v1966,
                                                            cond: ref v1967,
                                                        } = &v204.1 {
                                                            if let &Opcode::Icmp = v1965 {
                                                                match v1967 {
                                                                    &IntCC::SignedLessThan => {
                                                                        let mut v220 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v200.0, &mut v220);
                                                                        let mut v220 = v220.into_context_iter();
                                                                        while let Some(v221) = v220.next(ctx) {
                                                                            if let &InstructionData::IntCompare {
                                                                                opcode: ref v1959,
                                                                                args: ref v1960,
                                                                                cond: ref v1961,
                                                                            } = &v221.1 {
                                                                                if let &Opcode::Icmp = v1959 {
                                                                                    if let &IntCC::SignedGreaterThan = v1961 {
                                                                                        if v204.0 == v221.0 {
                                                                                            let v1962 = C::unpack_value_array_2(ctx, v1960);
                                                                                            let v1968 = C::unpack_value_array_2(ctx, v1966);
                                                                                            if v1962.0 == v1968.0 {
                                                                                                if v1962.1 == v1968.1 {
                                                                                                    let mut v1352 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                    C::inst_data_value_tupled_etor(ctx, v150.1, &mut v1352);
                                                                                                    let mut v1352 = v1352.into_context_iter();
                                                                                                    while let Some(v1353) = v1352.next(ctx) {
                                                                                                        let v1354 = C::iconst_sextend_etor(ctx, v1353);
                                                                                                        if let Some(v1355) = v1354 {
                                                                                                            if v1355.1 == 0_i64 {
                                                                                                                let v1979 = constructor_sge(ctx, v221.0, v1962.0, v1962.1);
                                                                                                                // Rule at src/opts/spaceship.isle line 171.
                                                                                                                returns.extend(Some(v1979));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        let mut v220 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v200.0, &mut v220);
                                                                        let mut v220 = v220.into_context_iter();
                                                                        while let Some(v221) = v220.next(ctx) {
                                                                            if let &InstructionData::IntCompare {
                                                                                opcode: ref v1959,
                                                                                args: ref v1960,
                                                                                cond: ref v1961,
                                                                            } = &v221.1 {
                                                                                if let &Opcode::Icmp = v1959 {
                                                                                    if let &IntCC::UnsignedGreaterThan = v1961 {
                                                                                        if v204.0 == v221.0 {
                                                                                            let v1962 = C::unpack_value_array_2(ctx, v1960);
                                                                                            let v1968 = C::unpack_value_array_2(ctx, v1966);
                                                                                            if v1962.0 == v1968.0 {
                                                                                                if v1962.1 == v1968.1 {
                                                                                                    let mut v1352 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                    C::inst_data_value_tupled_etor(ctx, v150.1, &mut v1352);
                                                                                                    let mut v1352 = v1352.into_context_iter();
                                                                                                    while let Some(v1353) = v1352.next(ctx) {
                                                                                                        let v1354 = C::iconst_sextend_etor(ctx, v1353);
                                                                                                        if let Some(v1355) = v1354 {
                                                                                                            if v1355.1 == 0_i64 {
                                                                                                                let v1980 = constructor_uge(ctx, v221.0, v1962.0, v1962.1);
                                                                                                                // Rule at src/opts/spaceship.isle line 173.
                                                                                                                returns.extend(Some(v1980));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                    &InstructionData::Unary {
                                        opcode: ref v299,
                                        arg: v300,
                                    } => {
                                        if let &Opcode::Uextend = v299 {
                                            if v154.0 == I64 {
                                                let v1348 = C::value_type(ctx, v300);
                                                if v1348 == I32 {
                                                    let mut v160 = C::inst_data_value_etor_returns::default();
                                                    C::inst_data_value_etor(ctx, v150.1, &mut v160);
                                                    let mut v160 = v160.into_context_iter();
                                                    while let Some(v161) = v160.next(ctx) {
                                                        if let &InstructionData::UnaryImm {
                                                            opcode: ref v210,
                                                            imm: v211,
                                                        } = &v161.1 {
                                                            if let &Opcode::Iconst = v210 {
                                                                let v212 = C::u64_from_imm64(ctx, v211);
                                                                if v212 == 0x0_u64 {
                                                                    let v1350 = constructor_iconst_u(ctx, v2.0, 0x1_u64);
                                                                    let v1351 = C::subsume(ctx, v1350);
                                                                    // Rule at src/opts/extends.isle line 32.
                                                                    returns.extend(Some(v1351));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                            let mut v160 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v150.1, &mut v160);
                            let mut v160 = v160.into_context_iter();
                            while let Some(v161) = v160.next(ctx) {
                                match &v161.1 {
                                    &InstructionData::Binary {
                                        opcode: ref v164,
                                        args: ref v165,
                                    } => {
                                        if let &Opcode::Smin = v164 {
                                            if v2.0 == v161.0 {
                                                let v166 = C::unpack_value_array_2(ctx, v165);
                                                if v150.0 == v166.0 {
                                                    let v290 = constructor_cmp_true(ctx, v2.0);
                                                    // Rule at src/opts/arithmetic.isle line 423.
                                                    returns.extend(Some(v290));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v150.0 == v166.1 {
                                                    let v290 = constructor_cmp_true(ctx, v2.0);
                                                    // Rule at src/opts/arithmetic.isle line 424.
                                                    returns.extend(Some(v290));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                    &InstructionData::UnaryImm {
                                        opcode: ref v210,
                                        imm: v211,
                                    } => {
                                        if let &Opcode::Iconst = v210 {
                                            let v334 = C::fits_in_64(ctx, v2.0);
                                            if let Some(v335) = v334 {
                                                let v1450 = C::ty_int(ctx, v335);
                                                if let Some(v1451) = v1450 {
                                                    let v212 = C::u64_from_imm64(ctx, v211);
                                                    let v1461 = C::ty_smin(ctx, v161.0);
                                                    let v1462 = C::u64_eq(ctx, v212, v1461);
                                                    if v1462 == true {
                                                        let v1457 = constructor_iconst_u(ctx, v1451, 0x1_u64);
                                                        let v1458 = C::subsume(ctx, v1457);
                                                        // Rule at src/opts/icmp.isle line 154.
                                                        returns.extend(Some(v1458));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                    let v1463 = C::ty_smax(ctx, v161.0);
                                                    let v1464 = C::u64_eq(ctx, v212, v1463);
                                                    if v1464 == true {
                                                        let v1452 = constructor_eq(ctx, v1451, v150.0, v150.1);
                                                        // Rule at src/opts/icmp.isle line 174.
                                                        returns.extend(Some(v1452));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                            if v150.0 == v150.1 {
                                let v339 = C::ty_int(ctx, v2.0);
                                if let Some(v340) = v339 {
                                    let v1395 = constructor_iconst_u(ctx, v340, 0x1_u64);
                                    let v1396 = C::subsume(ctx, v1395);
                                    // Rule at src/opts/icmp.isle line 9.
                                    returns.extend(Some(v1396));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                            let mut v1352 = C::inst_data_value_tupled_etor_returns::default();
                            C::inst_data_value_tupled_etor(ctx, v150.1, &mut v1352);
                            let mut v1352 = v1352.into_context_iter();
                            while let Some(v1353) = v1352.next(ctx) {
                                let v1354 = C::iconst_sextend_etor(ctx, v1353);
                                if let Some(v1355) = v1354 {
                                    if v1355.1 == 1_i64 {
                                        let v1475 = constructor_iconst_s(ctx, v1355.0, 0_i64);
                                        let v1476 = constructor_sgt(ctx, v2.0, v150.0, v1475);
                                        // Rule at src/opts/icmp.isle line 195.
                                        returns.extend(Some(v1476));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                            }
                        }
                        &IntCC::SignedLessThan => {
                            let v150 = C::unpack_value_array_2(ctx, v148);
                            let mut v153 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v150.0, &mut v153);
                            let mut v153 = v153.into_context_iter();
                            while let Some(v154) = v153.next(ctx) {
                                match &v154.1 {
                                    &InstructionData::Binary {
                                        opcode: ref v198,
                                        args: ref v199,
                                    } => {
                                        match v198 {
                                            &Opcode::Smax => {
                                                if v2.0 == v154.0 {
                                                    let v200 = C::unpack_value_array_2(ctx, v199);
                                                    if v150.1 == v200.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 v150.1 == v200.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; }
                                                    }
                                                }
                                            }
                                            &Opcode::Isub => {
                                                if v154.0 == I8 {
                                                    let v200 = C::unpack_value_array_2(ctx, v199);
                                                    let mut v203 = C::inst_data_value_etor_returns::default();
                                                    C::inst_data_value_etor(ctx, v200.1, &mut v203);
                                                    let mut v203 = v203.into_context_iter();
                                                    while let Some(v204) = v203.next(ctx) {
                                                        if let &InstructionData::IntCompare {
                                                            opcode: ref v1965,
                                                            args: ref v1966,
                                                            cond: ref v1967,
                                                        } = &v204.1 {
                                                            if let &Opcode::Icmp = v1965 {
                                                                match v1967 {
                                                                    &IntCC::SignedLessThan => {
                                                                        let mut v220 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v200.0, &mut v220);
                                                                        let mut v220 = v220.into_context_iter();
                                                                        while let Some(v221) = v220.next(ctx) {
                                                                            if let &InstructionData::IntCompare {
                                                                                opcode: ref v1959,
                                                                                args: ref v1960,
                                                                                cond: ref v1961,
                                                                            } = &v221.1 {
                                                                                if let &Opcode::Icmp = v1959 {
                                                                                    if let &IntCC::SignedGreaterThan = v1961 {
                                                                                        if v204.0 == v221.0 {
                                                                                            let v1962 = C::unpack_value_array_2(ctx, v1960);
                                                                                            let v1968 = C::unpack_value_array_2(ctx, v1966);
                                                                                            if v1962.0 == v1968.0 {
                                                                                                if v1962.1 == v1968.1 {
                                                                                                    let mut v1352 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                    C::inst_data_value_tupled_etor(ctx, v150.1, &mut v1352);
                                                                                                    let mut v1352 = v1352.into_context_iter();
                                                                                                    while let Some(v1353) = v1352.next(ctx) {
                                                                                                        let v1354 = C::iconst_sextend_etor(ctx, v1353);
                                                                                                        if let Some(v1355) = v1354 {
                                                                                                            if v1355.1 == 0_i64 {
                                                                                                                let v1973 = constructor_slt(ctx, v221.0, v1962.0, v1962.1);
                                                                                                                // Rule at src/opts/spaceship.isle line 156.
                                                                                                                returns.extend(Some(v1973));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        let mut v220 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v200.0, &mut v220);
                                                                        let mut v220 = v220.into_context_iter();
                                                                        while let Some(v221) = v220.next(ctx) {
                                                                            if let &InstructionData::IntCompare {
                                                                                opcode: ref v1959,
                                                                                args: ref v1960,
                                                                                cond: ref v1961,
                                                                            } = &v221.1 {
                                                                                if let &Opcode::Icmp = v1959 {
                                                                                    if let &IntCC::UnsignedGreaterThan = v1961 {
                                                                                        if v204.0 == v221.0 {
                                                                                            let v1962 = C::unpack_value_array_2(ctx, v1960);
                                                                                            let v1968 = C::unpack_value_array_2(ctx, v1966);
                                                                                            if v1962.0 == v1968.0 {
                                                                                                if v1962.1 == v1968.1 {
                                                                                                    let mut v1352 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                    C::inst_data_value_tupled_etor(ctx, v150.1, &mut v1352);
                                                                                                    let mut v1352 = v1352.into_context_iter();
                                                                                                    while let Some(v1353) = v1352.next(ctx) {
                                                                                                        let v1354 = C::iconst_sextend_etor(ctx, v1353);
                                                                                                        if let Some(v1355) = v1354 {
                                                                                                            if v1355.1 == 0_i64 {
                                                                                                                let v1974 = constructor_ult(ctx, v221.0, v1962.0, v1962.1);
                                                                                                                // Rule at src/opts/spaceship.isle line 158.
                                                                                                                returns.extend(Some(v1974));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                    &InstructionData::Unary {
                                        opcode: ref v299,
                                        arg: v300,
                                    } => {
                                        match v299 {
                                            &Opcode::Bnot => {
                                                let mut v160 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v150.1, &mut v160);
                                                let mut v160 = v160.into_context_iter();
                                                while let Some(v161) = v160.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v301,
                                                        arg: v302,
                                                    } = &v161.1 {
                                                        if let &Opcode::Bnot = v301 {
                                                            if v154.0 == v161.0 {
                                                                let v1544 = constructor_sgt(ctx, v2.0, v300, v302);
                                                                // Rule at src/opts/icmp.isle line 306.
                                                                returns.extend(Some(v1544));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            &Opcode::Uextend => {
                                                if v154.0 == I64 {
                                                    let v1348 = C::value_type(ctx, v300);
                                                    if v1348 == I32 {
                                                        let mut v160 = C::inst_data_value_etor_returns::default();
                                                        C::inst_data_value_etor(ctx, v150.1, &mut v160);
                                                        let mut v160 = v160.into_context_iter();
                                                        while let Some(v161) = v160.next(ctx) {
                                                            if let &InstructionData::UnaryImm {
                                                                opcode: ref v210,
                                                                imm: v211,
                                                            } = &v161.1 {
                                                                if let &Opcode::Iconst = v210 {
                                                                    let v212 = C::u64_from_imm64(ctx, v211);
                                                                    if v212 == 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 v334 = C::fits_in_64(ctx, v2.0);
                            if let Some(v335) = v334 {
                                let mut v160 = C::inst_data_value_etor_returns::default();
                                C::inst_data_value_etor(ctx, v150.1, &mut v160);
                                let mut v160 = v160.into_context_iter();
                                while let Some(v161) = v160.next(ctx) {
                                    match &v161.1 {
                                        &InstructionData::Binary {
                                            opcode: ref v164,
                                            args: ref v165,
                                        } => {
                                            if let &Opcode::Smin = v164 {
                                                let v166 = C::unpack_value_array_2(ctx, v165);
                                                if v150.0 == v166.0 {
                                                    let v1706 = constructor_iconst_u(ctx, v335, 0x0_u64);
                                                    // Rule at src/opts/selects.isle line 107.
                                                    returns.extend(Some(v1706));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v150.0 == v166.1 {
                                                    let v1706 = constructor_iconst_u(ctx, v335, 0x0_u64);
                                                    // Rule at src/opts/selects.isle line 108.
                                                    returns.extend(Some(v1706));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        &InstructionData::UnaryImm {
                                            opcode: ref v210,
                                            imm: v211,
                                        } => {
                                            if let &Opcode::Iconst = v210 {
                                                let v1450 = C::ty_int(ctx, v335);
                                                if let Some(v1451) = v1450 {
                                                    let v212 = C::u64_from_imm64(ctx, v211);
                                                    let v1461 = C::ty_smin(ctx, v161.0);
                                                    let v1462 = C::u64_eq(ctx, v212, v1461);
                                                    if v1462 == true {
                                                        let v1459 = constructor_iconst_u(ctx, v1451, 0x0_u64);
                                                        let v1460 = C::subsume(ctx, v1459);
                                                        // Rule at src/opts/icmp.isle line 139.
                                                        returns.extend(Some(v1460));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                    let v1463 = C::ty_smax(ctx, v161.0);
                                                    let v1464 = C::u64_eq(ctx, v212, v1463);
                                                    if v1464 == true {
                                                        let v1453 = constructor_ne(ctx, v1451, v150.0, v150.1);
                                                        // Rule at src/opts/icmp.isle line 159.
                                                        returns.extend(Some(v1453));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                            }
                            let v339 = C::ty_int(ctx, v2.0);
                            if let Some(v340) = v339 {
                                if v150.0 == v150.1 {
                                    let v341 = constructor_iconst_u(ctx, v340, 0x0_u64);
                                    let v342 = C::subsume(ctx, v341);
                                    // Rule at src/opts/icmp.isle line 12.
                                    returns.extend(Some(v342));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                            let mut v1352 = C::inst_data_value_tupled_etor_returns::default();
                            C::inst_data_value_tupled_etor(ctx, v150.1, &mut v1352);
                            let mut v1352 = v1352.into_context_iter();
                            while let Some(v1353) = v1352.next(ctx) {
                                let v1354 = C::iconst_sextend_etor(ctx, v1353);
                                if let Some(v1355) = v1354 {
                                    if v1355.1 == 1_i64 {
                                        let v1475 = constructor_iconst_s(ctx, v1355.0, 0_i64);
                                        let v1477 = constructor_sle(ctx, v2.0, v150.0, v1475);
                                        // Rule at src/opts/icmp.isle line 198.
                                        returns.extend(Some(v1477));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                            }
                        }
                        &IntCC::SignedLessThanOrEqual => {
                            let v150 = C::unpack_value_array_2(ctx, v148);
                            let mut v153 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v150.0, &mut v153);
                            let mut v153 = v153.into_context_iter();
                            while let Some(v154) = v153.next(ctx) {
                                if let &InstructionData::Binary {
                                    opcode: ref v198,
                                    args: ref v199,
                                } = &v154.1 {
                                    match v198 {
                                        &Opcode::Smin => {
                                            if v2.0 == v154.0 {
                                                let v200 = C::unpack_value_array_2(ctx, v199);
                                                if v150.1 == v200.0 {
                                                    let v290 = constructor_cmp_true(ctx, v2.0);
                                                    // Rule at src/opts/arithmetic.isle line 425.
                                                    returns.extend(Some(v290));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v150.1 == v200.1 {
                                                    let v290 = constructor_cmp_true(ctx, v2.0);
                                                    // Rule at src/opts/arithmetic.isle line 426.
                                                    returns.extend(Some(v290));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        &Opcode::Isub => {
                                            if v154.0 == I8 {
                                                let v200 = C::unpack_value_array_2(ctx, v199);
                                                let mut v203 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v200.1, &mut v203);
                                                let mut v203 = v203.into_context_iter();
                                                while let Some(v204) = v203.next(ctx) {
                                                    if let &InstructionData::IntCompare {
                                                        opcode: ref v1965,
                                                        args: ref v1966,
                                                        cond: ref v1967,
                                                    } = &v204.1 {
                                                        if let &Opcode::Icmp = v1965 {
                                                            match v1967 {
                                                                &IntCC::SignedLessThan => {
                                                                    let mut v220 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v200.0, &mut v220);
                                                                    let mut v220 = v220.into_context_iter();
                                                                    while let Some(v221) = v220.next(ctx) {
                                                                        if let &InstructionData::IntCompare {
                                                                            opcode: ref v1959,
                                                                            args: ref v1960,
                                                                            cond: ref v1961,
                                                                        } = &v221.1 {
                                                                            if let &Opcode::Icmp = v1959 {
                                                                                if let &IntCC::SignedGreaterThan = v1961 {
                                                                                    if v204.0 == v221.0 {
                                                                                        let v1962 = C::unpack_value_array_2(ctx, v1960);
                                                                                        let v1968 = C::unpack_value_array_2(ctx, v1966);
                                                                                        if v1962.0 == v1968.0 {
                                                                                            if v1962.1 == v1968.1 {
                                                                                                let mut v1352 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                C::inst_data_value_tupled_etor(ctx, v150.1, &mut v1352);
                                                                                                let mut v1352 = v1352.into_context_iter();
                                                                                                while let Some(v1353) = v1352.next(ctx) {
                                                                                                    let v1354 = C::iconst_sextend_etor(ctx, v1353);
                                                                                                    if let Some(v1355) = v1354 {
                                                                                                        if v1355.1 == 0_i64 {
                                                                                                            let v1975 = constructor_sle(ctx, v221.0, v1962.0, v1962.1);
                                                                                                            // Rule at src/opts/spaceship.isle line 161.
                                                                                                            returns.extend(Some(v1975));
                                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &IntCC::UnsignedLessThan => {
                                                                    let mut v220 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v200.0, &mut v220);
                                                                    let mut v220 = v220.into_context_iter();
                                                                    while let Some(v221) = v220.next(ctx) {
                                                                        if let &InstructionData::IntCompare {
                                                                            opcode: ref v1959,
                                                                            args: ref v1960,
                                                                            cond: ref v1961,
                                                                        } = &v221.1 {
                                                                            if let &Opcode::Icmp = v1959 {
                                                                                if let &IntCC::UnsignedGreaterThan = v1961 {
                                                                                    if v204.0 == v221.0 {
                                                                                        let v1962 = C::unpack_value_array_2(ctx, v1960);
                                                                                        let v1968 = C::unpack_value_array_2(ctx, v1966);
                                                                                        if v1962.0 == v1968.0 {
                                                                                            if v1962.1 == v1968.1 {
                                                                                                let mut v1352 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                C::inst_data_value_tupled_etor(ctx, v150.1, &mut v1352);
                                                                                                let mut v1352 = v1352.into_context_iter();
                                                                                                while let Some(v1353) = v1352.next(ctx) {
                                                                                                    let v1354 = C::iconst_sextend_etor(ctx, v1353);
                                                                                                    if let Some(v1355) = v1354 {
                                                                                                        if v1355.1 == 0_i64 {
                                                                                                            let v1976 = constructor_ule(ctx, v221.0, v1962.0, v1962.1);
                                                                                                            // Rule at src/opts/spaceship.isle line 163.
                                                                                                            returns.extend(Some(v1976));
                                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                            }
                            let mut v160 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v150.1, &mut v160);
                            let mut v160 = v160.into_context_iter();
                            while let Some(v161) = v160.next(ctx) {
                                match &v161.1 {
                                    &InstructionData::Binary {
                                        opcode: ref v164,
                                        args: ref v165,
                                    } => {
                                        if let &Opcode::Smax = v164 {
                                            if v2.0 == v161.0 {
                                                let v166 = C::unpack_value_array_2(ctx, v165);
                                                if v150.0 == v166.0 {
                                                    let v290 = constructor_cmp_true(ctx, v2.0);
                                                    // Rule at src/opts/arithmetic.isle line 415.
                                                    returns.extend(Some(v290));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v150.0 == v166.1 {
                                                    let v290 = constructor_cmp_true(ctx, v2.0);
                                                    // Rule at src/opts/arithmetic.isle line 416.
                                                    returns.extend(Some(v290));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                    &InstructionData::UnaryImm {
                                        opcode: ref v210,
                                        imm: v211,
                                    } => {
                                        if let &Opcode::Iconst = v210 {
                                            let v334 = C::fits_in_64(ctx, v2.0);
                                            if let Some(v335) = v334 {
                                                let v1450 = C::ty_int(ctx, v335);
                                                if let Some(v1451) = v1450 {
                                                    let v212 = C::u64_from_imm64(ctx, v211);
                                                    let v1461 = C::ty_smin(ctx, v161.0);
                                                    let v1462 = C::u64_eq(ctx, v212, v1461);
                                                    if v1462 == true {
                                                        let v1452 = constructor_eq(ctx, v1451, v150.0, v150.1);
                                                        // Rule at src/opts/icmp.isle line 144.
                                                        returns.extend(Some(v1452));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                    let v1463 = C::ty_smax(ctx, v161.0);
                                                    let v1464 = C::u64_eq(ctx, v212, v1463);
                                                    if v1464 == true {
                                                        let v1457 = constructor_iconst_u(ctx, v1451, 0x1_u64);
                                                        let v1458 = C::subsume(ctx, v1457);
                                                        // Rule at src/opts/icmp.isle line 164.
                                                        returns.extend(Some(v1458));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                            if v150.0 == v150.1 {
                                let v339 = C::ty_int(ctx, v2.0);
                                if let Some(v340) = v339 {
                                    let v1395 = constructor_iconst_u(ctx, v340, 0x1_u64);
                                    let v1396 = C::subsume(ctx, v1395);
                                    // Rule at src/opts/icmp.isle line 13.
                                    returns.extend(Some(v1396));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                            let mut v1352 = C::inst_data_value_tupled_etor_returns::default();
                            C::inst_data_value_tupled_etor(ctx, v150.1, &mut v1352);
                            let mut v1352 = v1352.into_context_iter();
                            while let Some(v1353) = v1352.next(ctx) {
                                let v1354 = C::iconst_sextend_etor(ctx, v1353);
                                if let Some(v1355) = v1354 {
                                    if v1355.1 == -1_i64 {
                                        let v1475 = constructor_iconst_s(ctx, v1355.0, 0_i64);
                                        let v1479 = constructor_slt(ctx, v2.0, v150.0, v1475);
                                        // Rule at src/opts/icmp.isle line 204.
                                        returns.extend(Some(v1479));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                            }
                        }
                        &IntCC::UnsignedGreaterThan => {
                            let v334 = C::fits_in_64(ctx, v2.0);
                            if let Some(v335) = v334 {
                                let v1450 = C::ty_int(ctx, v335);
                                if let Some(v1451) = v1450 {
                                    let v150 = C::unpack_value_array_2(ctx, v148);
                                    let mut v160 = C::inst_data_value_etor_returns::default();
                                    C::inst_data_value_etor(ctx, v150.1, &mut v160);
                                    let mut v160 = v160.into_context_iter();
                                    while let Some(v161) = v160.next(ctx) {
                                        if let &InstructionData::UnaryImm {
                                            opcode: ref v210,
                                            imm: v211,
                                        } = &v161.1 {
                                            if let &Opcode::Iconst = v210 {
                                                let v212 = C::u64_from_imm64(ctx, v211);
                                                if v212 == 0x0_u64 {
                                                    let v1453 = constructor_ne(ctx, v1451, v150.0, v150.1);
                                                    // Rule at src/opts/icmp.isle line 111.
                                                    returns.extend(Some(v1453));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let v1455 = C::ty_umax(ctx, v161.0);
                                                let v1456 = C::u64_eq(ctx, v212, v1455);
                                                if v1456 == true {
                                                    let v1459 = constructor_iconst_u(ctx, v1451, 0x0_u64);
                                                    let v1460 = C::subsume(ctx, v1459);
                                                    // Rule at src/opts/icmp.isle line 129.
                                                    returns.extend(Some(v1460));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                                let v150 = C::unpack_value_array_2(ctx, v148);
                                let mut v153 = C::inst_data_value_etor_returns::default();
                                C::inst_data_value_etor(ctx, v150.0, &mut v153);
                                let mut v153 = v153.into_context_iter();
                                while let Some(v154) = v153.next(ctx) {
                                    if let &InstructionData::Binary {
                                        opcode: ref v198,
                                        args: ref v199,
                                    } = &v154.1 {
                                        if let &Opcode::Umin = v198 {
                                            let v200 = C::unpack_value_array_2(ctx, v199);
                                            if v150.1 == v200.0 {
                                                let v1706 = constructor_iconst_u(ctx, v335, 0x0_u64);
                                                // Rule at src/opts/selects.isle line 109.
                                                returns.extend(Some(v1706));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            if v150.1 == v200.1 {
                                                let v1706 = constructor_iconst_u(ctx, v335, 0x0_u64);
                                                // Rule at src/opts/selects.isle line 110.
                                                returns.extend(Some(v1706));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                }
                            }
                            let v150 = C::unpack_value_array_2(ctx, v148);
                            let mut v160 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v150.1, &mut v160);
                            let mut v160 = v160.into_context_iter();
                            while let Some(v161) = v160.next(ctx) {
                                if let &InstructionData::Binary {
                                    opcode: ref v164,
                                    args: ref v165,
                                } = &v161.1 {
                                    if let &Opcode::Umax = v164 {
                                        if v2.0 == v161.0 {
                                            let v166 = C::unpack_value_array_2(ctx, v165);
                                            if v150.0 == v166.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 v150.0 == v166.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; }
                                            }
                                        }
                                    }
                                }
                            }
                            let v339 = C::ty_int(ctx, v2.0);
                            if let Some(v340) = v339 {
                                if v150.0 == v150.1 {
                                    let v341 = constructor_iconst_u(ctx, v340, 0x0_u64);
                                    let v342 = C::subsume(ctx, v341);
                                    // Rule at src/opts/icmp.isle line 6.
                                    returns.extend(Some(v342));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                            let mut v153 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v150.0, &mut v153);
                            let mut v153 = v153.into_context_iter();
                            while let Some(v154) = v153.next(ctx) {
                                if let &InstructionData::Binary {
                                    opcode: ref v198,
                                    args: ref v199,
                                } = &v154.1 {
                                    if let &Opcode::Isub = v198 {
                                        let v200 = C::unpack_value_array_2(ctx, v199);
                                        if v150.1 == v200.0 {
                                            let v1523 = constructor_ugt(ctx, v2.0, v200.1, v200.0);
                                            // Rule at src/opts/icmp.isle line 298.
                                            returns.extend(Some(v1523));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                            }
                        }
                        &IntCC::UnsignedGreaterThanOrEqual => {
                            let v150 = C::unpack_value_array_2(ctx, v148);
                            let mut v160 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v150.1, &mut v160);
                            let mut v160 = v160.into_context_iter();
                            while let Some(v161) = v160.next(ctx) {
                                match &v161.1 {
                                    &InstructionData::Binary {
                                        opcode: ref v164,
                                        args: ref v165,
                                    } => {
                                        match v164 {
                                            &Opcode::Umin => {
                                                if v2.0 == v161.0 {
                                                    let v166 = C::unpack_value_array_2(ctx, v165);
                                                    if v150.0 == v166.0 {
                                                        let v290 = constructor_cmp_true(ctx, v2.0);
                                                        // Rule at src/opts/arithmetic.isle line 427.
                                                        returns.extend(Some(v290));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                    if v150.0 == v166.1 {
                                                        let v290 = constructor_cmp_true(ctx, v2.0);
                                                        // Rule at src/opts/arithmetic.isle line 428.
                                                        returns.extend(Some(v290));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &Opcode::Band => {
                                                if v2.0 == v161.0 {
                                                    let v166 = C::unpack_value_array_2(ctx, v165);
                                                    if v150.0 == v166.0 {
                                                        let v290 = constructor_cmp_true(ctx, v2.0);
                                                        // Rule at src/opts/bitops.isle line 697.
                                                        returns.extend(Some(v290));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                    if v150.0 == v166.1 {
                                                        let v290 = constructor_cmp_true(ctx, v2.0);
                                                        // Rule at src/opts/bitops.isle line 698.
                                                        returns.extend(Some(v290));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                    &InstructionData::UnaryImm {
                                        opcode: ref v210,
                                        imm: v211,
                                    } => {
                                        if let &Opcode::Iconst = v210 {
                                            let v212 = C::u64_from_imm64(ctx, v211);
                                            match v212 {
                                                0x0_u64 => {
                                                    let v290 = constructor_cmp_true(ctx, v2.0);
                                                    let v1454 = C::subsume(ctx, v290);
                                                    // Rule at src/opts/icmp.isle line 115.
                                                    returns.extend(Some(v1454));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                0x1_u64 => {
                                                    let v293 = constructor_iconst_u(ctx, v161.0, 0x0_u64);
                                                    let v1473 = constructor_ne(ctx, v2.0, v150.0, v293);
                                                    // Rule at src/opts/icmp.isle line 189.
                                                    returns.extend(Some(v1473));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                _ => {}
                                            }
                                            let v334 = C::fits_in_64(ctx, v2.0);
                                            if let Some(v335) = v334 {
                                                let v1450 = C::ty_int(ctx, v335);
                                                if let Some(v1451) = v1450 {
                                                    let v1455 = C::ty_umax(ctx, v161.0);
                                                    let v1456 = C::u64_eq(ctx, v212, v1455);
                                                    if v1456 == true {
                                                        let v1452 = constructor_eq(ctx, v1451, v150.0, v150.1);
                                                        // Rule at src/opts/icmp.isle line 134.
                                                        returns.extend(Some(v1452));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                            let mut v153 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v150.0, &mut v153);
                            let mut v153 = v153.into_context_iter();
                            while let Some(v154) = v153.next(ctx) {
                                if let &InstructionData::Binary {
                                    opcode: ref v198,
                                    args: ref v199,
                                } = &v154.1 {
                                    match v198 {
                                        &Opcode::Umax => {
                                            if v2.0 == v154.0 {
                                                let v200 = C::unpack_value_array_2(ctx, v199);
                                                if v150.1 == v200.0 {
                                                    let v290 = constructor_cmp_true(ctx, v2.0);
                                                    // Rule at src/opts/arithmetic.isle line 417.
                                                    returns.extend(Some(v290));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v150.1 == v200.1 {
                                                    let v290 = constructor_cmp_true(ctx, v2.0);
                                                    // Rule at src/opts/arithmetic.isle line 418.
                                                    returns.extend(Some(v290));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        &Opcode::Bor => {
                                            if v2.0 == v154.0 {
                                                let v200 = C::unpack_value_array_2(ctx, v199);
                                                if v150.1 == v200.0 {
                                                    let v290 = constructor_cmp_true(ctx, v2.0);
                                                    // Rule at src/opts/bitops.isle line 703.
                                                    returns.extend(Some(v290));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v150.1 == v200.1 {
                                                    let v290 = constructor_cmp_true(ctx, v2.0);
                                                    // Rule at src/opts/bitops.isle line 704.
                                                    returns.extend(Some(v290));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                            }
                            if v150.0 == v150.1 {
                                let v339 = C::ty_int(ctx, v2.0);
                                if let Some(v340) = v339 {
                                    let v1395 = constructor_iconst_u(ctx, v340, 0x1_u64);
                                    let v1396 = C::subsume(ctx, v1395);
                                    // Rule at src/opts/icmp.isle line 7.
                                    returns.extend(Some(v1396));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                        }
                        &IntCC::UnsignedLessThan => {
                            let v150 = C::unpack_value_array_2(ctx, v148);
                            let mut v160 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v150.1, &mut v160);
                            let mut v160 = v160.into_context_iter();
                            while let Some(v161) = v160.next(ctx) {
                                match &v161.1 {
                                    &InstructionData::Binary {
                                        opcode: ref v164,
                                        args: ref v165,
                                    } => {
                                        if let &Opcode::Umin = v164 {
                                            let v334 = C::fits_in_64(ctx, v2.0);
                                            if let Some(v335) = v334 {
                                                let v166 = C::unpack_value_array_2(ctx, v165);
                                                if v150.0 == v166.0 {
                                                    let v1706 = constructor_iconst_u(ctx, v335, 0x0_u64);
                                                    // Rule at src/opts/selects.isle line 111.
                                                    returns.extend(Some(v1706));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v150.0 == v166.1 {
                                                    let v1706 = constructor_iconst_u(ctx, v335, 0x0_u64);
                                                    // Rule at src/opts/selects.isle line 112.
                                                    returns.extend(Some(v1706));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                    &InstructionData::Unary {
                                        opcode: ref v301,
                                        arg: v302,
                                    } => {
                                        if let &Opcode::Bnot = v301 {
                                            let mut v153 = C::inst_data_value_etor_returns::default();
                                            C::inst_data_value_etor(ctx, v150.0, &mut v153);
                                            let mut v153 = v153.into_context_iter();
                                            while let Some(v154) = v153.next(ctx) {
                                                if let &InstructionData::Unary {
                                                    opcode: ref v299,
                                                    arg: v300,
                                                } = &v154.1 {
                                                    if let &Opcode::Bnot = v299 {
                                                        if v154.0 == v161.0 {
                                                            let v1543 = constructor_ugt(ctx, v2.0, v300, v302);
                                                            // Rule at src/opts/icmp.isle line 305.
                                                            returns.extend(Some(v1543));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    &InstructionData::UnaryImm {
                                        opcode: ref v210,
                                        imm: v211,
                                    } => {
                                        if let &Opcode::Iconst = v210 {
                                            let v212 = C::u64_from_imm64(ctx, v211);
                                            match v212 {
                                                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 v293 = constructor_iconst_u(ctx, v161.0, 0x0_u64);
                                                    let v1474 = constructor_eq(ctx, v2.0, v150.0, v293);
                                                    // Rule at src/opts/icmp.isle line 192.
                                                    returns.extend(Some(v1474));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                _ => {}
                                            }
                                            let v334 = C::fits_in_64(ctx, v2.0);
                                            if let Some(v335) = v334 {
                                                let v1450 = C::ty_int(ctx, v335);
                                                if let Some(v1451) = v1450 {
                                                    let v1455 = C::ty_umax(ctx, v161.0);
                                                    let v1456 = C::u64_eq(ctx, v212, v1455);
                                                    if v1456 == true {
                                                        let v1453 = constructor_ne(ctx, v1451, v150.0, v150.1);
                                                        // Rule at src/opts/icmp.isle line 119.
                                                        returns.extend(Some(v1453));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                            let mut v153 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v150.0, &mut v153);
                            let mut v153 = v153.into_context_iter();
                            while let Some(v154) = v153.next(ctx) {
                                if let &InstructionData::Binary {
                                    opcode: ref v198,
                                    args: ref v199,
                                } = &v154.1 {
                                    if let &Opcode::Umax = v198 {
                                        if v2.0 == v154.0 {
                                            let v200 = C::unpack_value_array_2(ctx, v199);
                                            if v150.1 == v200.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 v150.1 == v200.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; }
                                            }
                                        }
                                    }
                                }
                            }
                            if v150.0 == v150.1 {
                                let v339 = C::ty_int(ctx, v2.0);
                                if let Some(v340) = v339 {
                                    let v341 = constructor_iconst_u(ctx, v340, 0x0_u64);
                                    let v342 = C::subsume(ctx, v341);
                                    // Rule at src/opts/icmp.isle line 10.
                                    returns.extend(Some(v342));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                        }
                        &IntCC::UnsignedLessThanOrEqual => {
                            let v150 = C::unpack_value_array_2(ctx, v148);
                            let mut v160 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v150.1, &mut v160);
                            let mut v160 = v160.into_context_iter();
                            while let Some(v161) = v160.next(ctx) {
                                match &v161.1 {
                                    &InstructionData::Binary {
                                        opcode: ref v164,
                                        args: ref v165,
                                    } => {
                                        match v164 {
                                            &Opcode::Umax => {
                                                if v2.0 == v161.0 {
                                                    let v166 = C::unpack_value_array_2(ctx, v165);
                                                    if v150.0 == v166.0 {
                                                        let v290 = constructor_cmp_true(ctx, v2.0);
                                                        // Rule at src/opts/arithmetic.isle line 419.
                                                        returns.extend(Some(v290));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                    if v150.0 == v166.1 {
                                                        let v290 = constructor_cmp_true(ctx, v2.0);
                                                        // Rule at src/opts/arithmetic.isle line 420.
                                                        returns.extend(Some(v290));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &Opcode::Bor => {
                                                if v2.0 == v161.0 {
                                                    let v166 = C::unpack_value_array_2(ctx, v165);
                                                    if v150.0 == v166.0 {
                                                        let v290 = constructor_cmp_true(ctx, v2.0);
                                                        // Rule at src/opts/bitops.isle line 705.
                                                        returns.extend(Some(v290));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                    if v150.0 == v166.1 {
                                                        let v290 = constructor_cmp_true(ctx, v2.0);
                                                        // Rule at src/opts/bitops.isle line 706.
                                                        returns.extend(Some(v290));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                    &InstructionData::UnaryImm {
                                        opcode: ref v210,
                                        imm: v211,
                                    } => {
                                        if let &Opcode::Iconst = v210 {
                                            let v334 = C::fits_in_64(ctx, v2.0);
                                            if let Some(v335) = v334 {
                                                let v1450 = C::ty_int(ctx, v335);
                                                if let Some(v1451) = v1450 {
                                                    let v212 = C::u64_from_imm64(ctx, v211);
                                                    if v212 == 0x0_u64 {
                                                        let v1452 = constructor_eq(ctx, v1451, v150.0, v150.1);
                                                        // Rule at src/opts/icmp.isle line 107.
                                                        returns.extend(Some(v1452));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                    let v1455 = C::ty_umax(ctx, v161.0);
                                                    let v1456 = C::u64_eq(ctx, v212, v1455);
                                                    if v1456 == true {
                                                        let v1457 = constructor_iconst_u(ctx, v1451, 0x1_u64);
                                                        let v1458 = C::subsume(ctx, v1457);
                                                        // Rule at src/opts/icmp.isle line 124.
                                                        returns.extend(Some(v1458));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                            let mut v153 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v150.0, &mut v153);
                            let mut v153 = v153.into_context_iter();
                            while let Some(v154) = v153.next(ctx) {
                                if let &InstructionData::Binary {
                                    opcode: ref v198,
                                    args: ref v199,
                                } = &v154.1 {
                                    match v198 {
                                        &Opcode::Umin => {
                                            if v2.0 == v154.0 {
                                                let v200 = C::unpack_value_array_2(ctx, v199);
                                                if v150.1 == v200.0 {
                                                    let v290 = constructor_cmp_true(ctx, v2.0);
                                                    // Rule at src/opts/arithmetic.isle line 429.
                                                    returns.extend(Some(v290));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v150.1 == v200.1 {
                                                    let v290 = constructor_cmp_true(ctx, v2.0);
                                                    // Rule at src/opts/arithmetic.isle line 430.
                                                    returns.extend(Some(v290));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        &Opcode::Isub => {
                                            let v200 = C::unpack_value_array_2(ctx, v199);
                                            if v150.1 == v200.0 {
                                                let v1524 = constructor_ule(ctx, v2.0, v200.1, v200.0);
                                                // Rule at src/opts/icmp.isle line 299.
                                                returns.extend(Some(v1524));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        &Opcode::Band => {
                                            if v2.0 == v154.0 {
                                                let v200 = C::unpack_value_array_2(ctx, v199);
                                                if v150.1 == v200.0 {
                                                    let v290 = constructor_cmp_true(ctx, v2.0);
                                                    // Rule at src/opts/bitops.isle line 699.
                                                    returns.extend(Some(v290));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v150.1 == v200.1 {
                                                    let v290 = constructor_cmp_true(ctx, v2.0);
                                                    // Rule at src/opts/bitops.isle line 700.
                                                    returns.extend(Some(v290));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                            }
                            if v150.0 == v150.1 {
                                let v339 = C::ty_int(ctx, v2.0);
                                if let Some(v340) = v339 {
                                    let v1395 = constructor_iconst_u(ctx, v340, 0x1_u64);
                                    let v1396 = C::subsume(ctx, v1395);
                                    // Rule at src/opts/icmp.isle line 11.
                                    returns.extend(Some(v1396));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                        }
                        _ => {}
                    }
                    let v150 = C::unpack_value_array_2(ctx, v148);
                    let mut v153 = C::inst_data_value_etor_returns::default();
                    C::inst_data_value_etor(ctx, v150.0, &mut v153);
                    let mut v153 = v153.into_context_iter();
                    while let Some(v154) = v153.next(ctx) {
                        match &v154.1 {
                            &InstructionData::Unary {
                                opcode: ref v299,
                                arg: v300,
                            } => {
                                if let &Opcode::Sextend = v299 {
                                    let v1362 = &C::signed_cond_code(ctx, v149);
                                    if let Some(v1363) = v1362 {
                                        let mut v1352 = C::inst_data_value_tupled_etor_returns::default();
                                        C::inst_data_value_tupled_etor(ctx, v150.1, &mut v1352);
                                        let mut v1352 = v1352.into_context_iter();
                                        while let Some(v1353) = v1352.next(ctx) {
                                            let v1354 = C::iconst_sextend_etor(ctx, v1353);
                                            if let Some(v1355) = v1354 {
                                                if v1355.1 == 0_i64 {
                                                    let v1348 = C::value_type(ctx, v300);
                                                    let v1359 = constructor_iconst_s(ctx, v1348, 0_i64);
                                                    let v1364 = constructor_icmp(ctx, v1348, v149, v300, v1359);
                                                    // Rule at src/opts/extends.isle line 43.
                                                    returns.extend(Some(v1364));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            &InstructionData::UnaryImm {
                                opcode: ref v157,
                                imm: v158,
                            } => {
                                if let &Opcode::Iconst = v157 {
                                    let mut v160 = C::inst_data_value_etor_returns::default();
                                    C::inst_data_value_etor(ctx, v150.1, &mut v160);
                                    let mut v160 = v160.into_context_iter();
                                    while let Some(v161) = v160.next(ctx) {
                                        if let &InstructionData::UnaryImm {
                                            opcode: ref v210,
                                            imm: v211,
                                        } = &v161.1 {
                                            if let &Opcode::Iconst = v210 {
                                                if v154.0 == v161.0 {
                                                    let v1016 = C::imm64_icmp(ctx, v154.0, v149, v158, v211);
                                                    let v1017 = constructor_iconst(ctx, v2.0, v1016);
                                                    let v1018 = C::subsume(ctx, v1017);
                                                    // Rule at src/opts/cprop.isle line 134.
                                                    returns.extend(Some(v1018));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                    let v1030 = &C::intcc_swap_args(ctx, v149);
                                    let v1031 = constructor_icmp(ctx, v2.0, v1030, v150.1, v150.0);
                                    // Rule at src/opts/cprop.isle line 173.
                                    returns.extend(Some(v1031));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                            _ => {}
                        }
                    }
                }
            }
            &InstructionData::Ternary {
                opcode: ref v77,
                args: ref v78,
            } => {
                match v77 {
                    &Opcode::Select => {
                        let v79 = C::unpack_value_array_3(ctx, v78);
                        let mut v83 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v79.0, &mut v83);
                        let mut v83 = v83.into_context_iter();
                        while let Some(v84) = v83.next(ctx) {
                            match &v84.1 {
                                &InstructionData::Binary {
                                    opcode: ref v1709,
                                    args: ref v1710,
                                } => {
                                    if let &Opcode::Bor = v1709 {
                                        let v1711 = C::unpack_value_array_2(ctx, v1710);
                                        let mut v1714 = C::inst_data_value_etor_returns::default();
                                        C::inst_data_value_etor(ctx, v1711.1, &mut v1714);
                                        let mut v1714 = v1714.into_context_iter();
                                        while let Some(v1715) = v1714.next(ctx) {
                                            if let &InstructionData::IntCompare {
                                                opcode: ref v1718,
                                                args: ref v1719,
                                                cond: ref v1720,
                                            } = &v1715.1 {
                                                if let &Opcode::Icmp = v1718 {
                                                    if let &IntCC::NotEqual = v1720 {
                                                        if v84.0 == v1715.0 {
                                                            let v1721 = C::unpack_value_array_2(ctx, v1719);
                                                            if v79.1 == v1721.0 {
                                                                if v79.2 == v1721.1 {
                                                                    let v1724 = C::subsume(ctx, v1721.0);
                                                                    // Rule at src/opts/selects.isle line 122.
                                                                    returns.extend(Some(v1724));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                            if v79.1 == v1721.1 {
                                                                if v79.2 == v1721.0 {
                                                                    let v1736 = C::subsume(ctx, v1721.1);
                                                                    // Rule at src/opts/selects.isle line 124.
                                                                    returns.extend(Some(v1736));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        let mut v1725 = C::inst_data_value_etor_returns::default();
                                        C::inst_data_value_etor(ctx, v1711.0, &mut v1725);
                                        let mut v1725 = v1725.into_context_iter();
                                        while let Some(v1726) = v1725.next(ctx) {
                                            if let &InstructionData::IntCompare {
                                                opcode: ref v1729,
                                                args: ref v1730,
                                                cond: ref v1731,
                                            } = &v1726.1 {
                                                if let &Opcode::Icmp = v1729 {
                                                    if let &IntCC::NotEqual = v1731 {
                                                        if v84.0 == v1726.0 {
                                                            let v1732 = C::unpack_value_array_2(ctx, v1730);
                                                            if v79.1 == v1732.0 {
                                                                if v79.2 == v1732.1 {
                                                                    let v1735 = C::subsume(ctx, v1732.0);
                                                                    // Rule at src/opts/selects.isle line 123.
                                                                    returns.extend(Some(v1735));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                            if v79.1 == v1732.1 {
                                                                if v79.2 == v1732.0 {
                                                                    let v1737 = C::subsume(ctx, v1732.1);
                                                                    // Rule at src/opts/selects.isle line 125.
                                                                    returns.extend(Some(v1737));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::IntCompare {
                                    opcode: ref v1480,
                                    args: ref v1481,
                                    cond: ref v1482,
                                } => {
                                    if let &Opcode::Icmp = v1480 {
                                        match v1482 {
                                            &IntCC::Equal => {
                                                let mut v1496 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v79.2, &mut v1496);
                                                let mut v1496 = v1496.into_context_iter();
                                                while let Some(v1497) = v1496.next(ctx) {
                                                    match &v1497.1 {
                                                        &InstructionData::Binary {
                                                            opcode: ref v1738,
                                                            args: ref v1739,
                                                        } => {
                                                            match v1738 {
                                                                &Opcode::Isub => {
                                                                    if v2.0 == v1497.0 {
                                                                        let mut v89 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v79.1, &mut v89);
                                                                        let mut v89 = v89.into_context_iter();
                                                                        while let Some(v90) = v89.next(ctx) {
                                                                            if let &InstructionData::Binary {
                                                                                opcode: ref v1744,
                                                                                args: ref v1745,
                                                                            } = &v90.1 {
                                                                                if let &Opcode::Isub = v1744 {
                                                                                    if v2.0 == v90.0 {
                                                                                        let v1740 = C::unpack_value_array_2(ctx, v1739);
                                                                                        let v1746 = C::unpack_value_array_2(ctx, v1745);
                                                                                        if v1740.0 == v1746.0 {
                                                                                            let mut v1758 = C::inst_data_value_etor_returns::default();
                                                                                            C::inst_data_value_etor(ctx, v1746.1, &mut v1758);
                                                                                            let mut v1758 = v1758.into_context_iter();
                                                                                            while let Some(v1759) = v1758.next(ctx) {
                                                                                                if let &InstructionData::UnaryImm {
                                                                                                    opcode: ref v1762,
                                                                                                    imm: v1763,
                                                                                                } = &v1759.1 {
                                                                                                    if let &Opcode::Iconst = v1762 {
                                                                                                        if v2.0 == v1759.0 {
                                                                                                            let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                                                            if v1483.0 == v1740.1 {
                                                                                                                let mut v1660 = C::inst_data_value_etor_returns::default();
                                                                                                                C::inst_data_value_etor(ctx, v1483.1, &mut v1660);
                                                                                                                let mut v1660 = v1660.into_context_iter();
                                                                                                                while let Some(v1661) = v1660.next(ctx) {
                                                                                                                    if let &InstructionData::UnaryImm {
                                                                                                                        opcode: ref v1664,
                                                                                                                        imm: v1665,
                                                                                                                    } = &v1661.1 {
                                                                                                                        if let &Opcode::Iconst = v1664 {
                                                                                                                            if v2.0 == v1661.0 {
                                                                                                                                let v1666 = C::u64_from_imm64(ctx, v1665);
                                                                                                                                let v1764 = C::u64_from_imm64(ctx, v1763);
                                                                                                                                if v1666 == v1764 {
                                                                                                                                    let v1765 = constructor_isub(ctx, v2.0, v1746.0, v1483.0);
                                                                                                                                    // Rule at src/opts/selects.isle line 185.
                                                                                                                                    returns.extend(Some(v1765));
                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                            if v1483.1 == v1740.1 {
                                                                                                                let mut v1773 = C::inst_data_value_etor_returns::default();
                                                                                                                C::inst_data_value_etor(ctx, v1483.0, &mut v1773);
                                                                                                                let mut v1773 = v1773.into_context_iter();
                                                                                                                while let Some(v1774) = v1773.next(ctx) {
                                                                                                                    if let &InstructionData::UnaryImm {
                                                                                                                        opcode: ref v1777,
                                                                                                                        imm: v1778,
                                                                                                                    } = &v1774.1 {
                                                                                                                        if let &Opcode::Iconst = v1777 {
                                                                                                                            if v2.0 == v1774.0 {
                                                                                                                                let v1764 = C::u64_from_imm64(ctx, v1763);
                                                                                                                                let v1779 = C::u64_from_imm64(ctx, v1778);
                                                                                                                                if v1764 == v1779 {
                                                                                                                                    let v1780 = constructor_isub(ctx, v2.0, v1746.0, v1483.1);
                                                                                                                                    // Rule at src/opts/selects.isle line 187.
                                                                                                                                    returns.extend(Some(v1780));
                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Band => {
                                                                    if v2.0 == v1497.0 {
                                                                        let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                        if v79.1 == v1483.0 {
                                                                            let v1740 = C::unpack_value_array_2(ctx, v1739);
                                                                            if v79.1 == v1740.0 {
                                                                                if v1483.1 == v1740.1 {
                                                                                    let v1751 = constructor_band(ctx, v2.0, v1483.1, v1483.0);
                                                                                    // Rule at src/opts/selects.isle line 147.
                                                                                    returns.extend(Some(v1751));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                            if v79.1 == v1740.1 {
                                                                                if v1483.1 == v1740.0 {
                                                                                    let v1751 = constructor_band(ctx, v2.0, v1483.1, v1483.0);
                                                                                    // Rule at src/opts/selects.isle line 145.
                                                                                    returns.extend(Some(v1751));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                        if v79.1 == v1483.1 {
                                                                            let v1740 = C::unpack_value_array_2(ctx, v1739);
                                                                            if v79.1 == v1740.0 {
                                                                                if v1483.0 == v1740.1 {
                                                                                    let v1750 = constructor_band(ctx, v2.0, v1483.0, v1483.1);
                                                                                    // Rule at src/opts/selects.isle line 143.
                                                                                    returns.extend(Some(v1750));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                            if v1483.0 == v1740.0 {
                                                                                if v79.1 == v1740.1 {
                                                                                    let v1750 = constructor_band(ctx, v2.0, v1483.0, v1483.1);
                                                                                    // Rule at src/opts/selects.isle line 141.
                                                                                    returns.extend(Some(v1750));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Bor => {
                                                                    if v2.0 == v1497.0 {
                                                                        let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                        if v79.1 == v1483.0 {
                                                                            let v1740 = C::unpack_value_array_2(ctx, v1739);
                                                                            if v79.1 == v1740.0 {
                                                                                if v1483.1 == v1740.1 {
                                                                                    let v1743 = constructor_bor(ctx, v2.0, v1483.0, v1483.1);
                                                                                    // Rule at src/opts/selects.isle line 129.
                                                                                    returns.extend(Some(v1743));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                            if v79.1 == v1740.1 {
                                                                                if v1483.1 == v1740.0 {
                                                                                    let v1743 = constructor_bor(ctx, v2.0, v1483.0, v1483.1);
                                                                                    // Rule at src/opts/selects.isle line 131.
                                                                                    returns.extend(Some(v1743));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                        if v79.1 == v1483.1 {
                                                                            let v1740 = C::unpack_value_array_2(ctx, v1739);
                                                                            if v79.1 == v1740.0 {
                                                                                if v1483.0 == v1740.1 {
                                                                                    let v1749 = constructor_bor(ctx, v2.0, v1483.1, v1483.0);
                                                                                    // Rule at src/opts/selects.isle line 133.
                                                                                    returns.extend(Some(v1749));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                            if v1483.0 == v1740.0 {
                                                                                if v79.1 == v1740.1 {
                                                                                    let v1749 = constructor_bor(ctx, v2.0, v1483.1, v1483.0);
                                                                                    // Rule at src/opts/selects.isle line 135.
                                                                                    returns.extend(Some(v1749));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                        &InstructionData::IntCompare {
                                                            opcode: ref v1500,
                                                            args: ref v1501,
                                                            cond: ref v1502,
                                                        } => {
                                                            if let &Opcode::Icmp = v1500 {
                                                                match v1502 {
                                                                    &IntCC::SignedGreaterThan => {
                                                                        let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                        let v1486 = C::value_type(ctx, v1483.0);
                                                                        if v1486 == I64 {
                                                                            let v1487 = C::value_type(ctx, v1483.1);
                                                                            if v1487 == I64 {
                                                                                if v2.0 == v1497.0 {
                                                                                    let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                                    if v1483.0 == v1503.0 {
                                                                                        if v1483.1 == v1503.1 {
                                                                                            let mut v89 = C::inst_data_value_etor_returns::default();
                                                                                            C::inst_data_value_etor(ctx, v79.1, &mut v89);
                                                                                            let mut v89 = v89.into_context_iter();
                                                                                            while let Some(v90) = v89.next(ctx) {
                                                                                                if let &InstructionData::IntCompare {
                                                                                                    opcode: ref v1488,
                                                                                                    args: ref v1489,
                                                                                                    cond: ref v1490,
                                                                                                } = &v90.1 {
                                                                                                    if let &Opcode::Icmp = v1488 {
                                                                                                        if let &IntCC::UnsignedGreaterThan = v1490 {
                                                                                                            let v1491 = C::unpack_value_array_2(ctx, v1489);
                                                                                                            let v1494 = C::value_type(ctx, v1491.0);
                                                                                                            if v1494 == I64 {
                                                                                                                let v1495 = C::value_type(ctx, v1491.1);
                                                                                                                if v1495 == I64 {
                                                                                                                    if v2.0 == v90.0 {
                                                                                                                        let v1506 = constructor_iconcat(ctx, I64, v1491.0, v1483.0);
                                                                                                                        let v1507 = constructor_iconcat(ctx, I64, v1491.1, v1483.1);
                                                                                                                        let v1511 = constructor_sgt(ctx, v2.0, v1506, v1507);
                                                                                                                        // Rule at src/opts/icmp.isle line 268.
                                                                                                                        returns.extend(Some(v1511));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedGreaterThanOrEqual => {
                                                                        let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                        let v1486 = C::value_type(ctx, v1483.0);
                                                                        if v1486 == I64 {
                                                                            let v1487 = C::value_type(ctx, v1483.1);
                                                                            if v1487 == I64 {
                                                                                if v2.0 == v1497.0 {
                                                                                    let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                                    if v1483.0 == v1503.0 {
                                                                                        if v1483.1 == v1503.1 {
                                                                                            let mut v89 = C::inst_data_value_etor_returns::default();
                                                                                            C::inst_data_value_etor(ctx, v79.1, &mut v89);
                                                                                            let mut v89 = v89.into_context_iter();
                                                                                            while let Some(v90) = v89.next(ctx) {
                                                                                                if let &InstructionData::IntCompare {
                                                                                                    opcode: ref v1488,
                                                                                                    args: ref v1489,
                                                                                                    cond: ref v1490,
                                                                                                } = &v90.1 {
                                                                                                    if let &Opcode::Icmp = v1488 {
                                                                                                        if let &IntCC::UnsignedGreaterThanOrEqual = v1490 {
                                                                                                            let v1491 = C::unpack_value_array_2(ctx, v1489);
                                                                                                            let v1494 = C::value_type(ctx, v1491.0);
                                                                                                            if v1494 == I64 {
                                                                                                                let v1495 = C::value_type(ctx, v1491.1);
                                                                                                                if v1495 == I64 {
                                                                                                                    if v2.0 == v90.0 {
                                                                                                                        let v1506 = constructor_iconcat(ctx, I64, v1491.0, v1483.0);
                                                                                                                        let v1507 = constructor_iconcat(ctx, I64, v1491.1, v1483.1);
                                                                                                                        let v1509 = constructor_sge(ctx, v2.0, v1506, v1507);
                                                                                                                        // Rule at src/opts/icmp.isle line 258.
                                                                                                                        returns.extend(Some(v1509));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedLessThan => {
                                                                        let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                        let v1486 = C::value_type(ctx, v1483.0);
                                                                        if v1486 == I64 {
                                                                            let v1487 = C::value_type(ctx, v1483.1);
                                                                            if v1487 == I64 {
                                                                                if v2.0 == v1497.0 {
                                                                                    let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                                    if v1483.0 == v1503.0 {
                                                                                        if v1483.1 == v1503.1 {
                                                                                            let mut v89 = C::inst_data_value_etor_returns::default();
                                                                                            C::inst_data_value_etor(ctx, v79.1, &mut v89);
                                                                                            let mut v89 = v89.into_context_iter();
                                                                                            while let Some(v90) = v89.next(ctx) {
                                                                                                if let &InstructionData::IntCompare {
                                                                                                    opcode: ref v1488,
                                                                                                    args: ref v1489,
                                                                                                    cond: ref v1490,
                                                                                                } = &v90.1 {
                                                                                                    if let &Opcode::Icmp = v1488 {
                                                                                                        if let &IntCC::UnsignedLessThan = v1490 {
                                                                                                            let v1491 = C::unpack_value_array_2(ctx, v1489);
                                                                                                            let v1494 = C::value_type(ctx, v1491.0);
                                                                                                            if v1494 == I64 {
                                                                                                                let v1495 = C::value_type(ctx, v1491.1);
                                                                                                                if v1495 == I64 {
                                                                                                                    if v2.0 == v90.0 {
                                                                                                                        let v1506 = constructor_iconcat(ctx, I64, v1491.0, v1483.0);
                                                                                                                        let v1507 = constructor_iconcat(ctx, I64, v1491.1, v1483.1);
                                                                                                                        let v1515 = constructor_slt(ctx, v2.0, v1506, v1507);
                                                                                                                        // Rule at src/opts/icmp.isle line 288.
                                                                                                                        returns.extend(Some(v1515));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedLessThanOrEqual => {
                                                                        let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                        let v1486 = C::value_type(ctx, v1483.0);
                                                                        if v1486 == I64 {
                                                                            let v1487 = C::value_type(ctx, v1483.1);
                                                                            if v1487 == I64 {
                                                                                if v2.0 == v1497.0 {
                                                                                    let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                                    if v1483.0 == v1503.0 {
                                                                                        if v1483.1 == v1503.1 {
                                                                                            let mut v89 = C::inst_data_value_etor_returns::default();
                                                                                            C::inst_data_value_etor(ctx, v79.1, &mut v89);
                                                                                            let mut v89 = v89.into_context_iter();
                                                                                            while let Some(v90) = v89.next(ctx) {
                                                                                                if let &InstructionData::IntCompare {
                                                                                                    opcode: ref v1488,
                                                                                                    args: ref v1489,
                                                                                                    cond: ref v1490,
                                                                                                } = &v90.1 {
                                                                                                    if let &Opcode::Icmp = v1488 {
                                                                                                        if let &IntCC::UnsignedLessThanOrEqual = v1490 {
                                                                                                            let v1491 = C::unpack_value_array_2(ctx, v1489);
                                                                                                            let v1494 = C::value_type(ctx, v1491.0);
                                                                                                            if v1494 == I64 {
                                                                                                                let v1495 = C::value_type(ctx, v1491.1);
                                                                                                                if v1495 == I64 {
                                                                                                                    if v2.0 == v90.0 {
                                                                                                                        let v1506 = constructor_iconcat(ctx, I64, v1491.0, v1483.0);
                                                                                                                        let v1507 = constructor_iconcat(ctx, I64, v1491.1, v1483.1);
                                                                                                                        let v1513 = constructor_sle(ctx, v2.0, v1506, v1507);
                                                                                                                        // Rule at src/opts/icmp.isle line 278.
                                                                                                                        returns.extend(Some(v1513));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedGreaterThan => {
                                                                        let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                        let v1486 = C::value_type(ctx, v1483.0);
                                                                        if v1486 == I64 {
                                                                            let v1487 = C::value_type(ctx, v1483.1);
                                                                            if v1487 == I64 {
                                                                                if v2.0 == v1497.0 {
                                                                                    let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                                    if v1483.0 == v1503.0 {
                                                                                        if v1483.1 == v1503.1 {
                                                                                            let mut v89 = C::inst_data_value_etor_returns::default();
                                                                                            C::inst_data_value_etor(ctx, v79.1, &mut v89);
                                                                                            let mut v89 = v89.into_context_iter();
                                                                                            while let Some(v90) = v89.next(ctx) {
                                                                                                if let &InstructionData::IntCompare {
                                                                                                    opcode: ref v1488,
                                                                                                    args: ref v1489,
                                                                                                    cond: ref v1490,
                                                                                                } = &v90.1 {
                                                                                                    if let &Opcode::Icmp = v1488 {
                                                                                                        if let &IntCC::UnsignedGreaterThan = v1490 {
                                                                                                            let v1491 = C::unpack_value_array_2(ctx, v1489);
                                                                                                            let v1494 = C::value_type(ctx, v1491.0);
                                                                                                            if v1494 == I64 {
                                                                                                                let v1495 = C::value_type(ctx, v1491.1);
                                                                                                                if v1495 == I64 {
                                                                                                                    if v2.0 == v90.0 {
                                                                                                                        let v1506 = constructor_iconcat(ctx, I64, v1491.0, v1483.0);
                                                                                                                        let v1507 = constructor_iconcat(ctx, I64, v1491.1, v1483.1);
                                                                                                                        let v1510 = constructor_ugt(ctx, v2.0, v1506, v1507);
                                                                                                                        // Rule at src/opts/icmp.isle line 263.
                                                                                                                        returns.extend(Some(v1510));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedGreaterThanOrEqual => {
                                                                        let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                        let v1486 = C::value_type(ctx, v1483.0);
                                                                        if v1486 == I64 {
                                                                            let v1487 = C::value_type(ctx, v1483.1);
                                                                            if v1487 == I64 {
                                                                                if v2.0 == v1497.0 {
                                                                                    let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                                    if v1483.0 == v1503.0 {
                                                                                        if v1483.1 == v1503.1 {
                                                                                            let mut v89 = C::inst_data_value_etor_returns::default();
                                                                                            C::inst_data_value_etor(ctx, v79.1, &mut v89);
                                                                                            let mut v89 = v89.into_context_iter();
                                                                                            while let Some(v90) = v89.next(ctx) {
                                                                                                if let &InstructionData::IntCompare {
                                                                                                    opcode: ref v1488,
                                                                                                    args: ref v1489,
                                                                                                    cond: ref v1490,
                                                                                                } = &v90.1 {
                                                                                                    if let &Opcode::Icmp = v1488 {
                                                                                                        if let &IntCC::UnsignedGreaterThanOrEqual = v1490 {
                                                                                                            let v1491 = C::unpack_value_array_2(ctx, v1489);
                                                                                                            let v1494 = C::value_type(ctx, v1491.0);
                                                                                                            if v1494 == I64 {
                                                                                                                let v1495 = C::value_type(ctx, v1491.1);
                                                                                                                if v1495 == I64 {
                                                                                                                    if v2.0 == v90.0 {
                                                                                                                        let v1506 = constructor_iconcat(ctx, I64, v1491.0, v1483.0);
                                                                                                                        let v1507 = constructor_iconcat(ctx, I64, v1491.1, v1483.1);
                                                                                                                        let v1508 = constructor_uge(ctx, v2.0, v1506, v1507);
                                                                                                                        // Rule at src/opts/icmp.isle line 253.
                                                                                                                        returns.extend(Some(v1508));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                        let v1486 = C::value_type(ctx, v1483.0);
                                                                        if v1486 == I64 {
                                                                            let v1487 = C::value_type(ctx, v1483.1);
                                                                            if v1487 == I64 {
                                                                                if v2.0 == v1497.0 {
                                                                                    let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                                    if v1483.0 == v1503.0 {
                                                                                        if v1483.1 == v1503.1 {
                                                                                            let mut v89 = C::inst_data_value_etor_returns::default();
                                                                                            C::inst_data_value_etor(ctx, v79.1, &mut v89);
                                                                                            let mut v89 = v89.into_context_iter();
                                                                                            while let Some(v90) = v89.next(ctx) {
                                                                                                if let &InstructionData::IntCompare {
                                                                                                    opcode: ref v1488,
                                                                                                    args: ref v1489,
                                                                                                    cond: ref v1490,
                                                                                                } = &v90.1 {
                                                                                                    if let &Opcode::Icmp = v1488 {
                                                                                                        if let &IntCC::UnsignedLessThan = v1490 {
                                                                                                            let v1491 = C::unpack_value_array_2(ctx, v1489);
                                                                                                            let v1494 = C::value_type(ctx, v1491.0);
                                                                                                            if v1494 == I64 {
                                                                                                                let v1495 = C::value_type(ctx, v1491.1);
                                                                                                                if v1495 == I64 {
                                                                                                                    if v2.0 == v90.0 {
                                                                                                                        let v1506 = constructor_iconcat(ctx, I64, v1491.0, v1483.0);
                                                                                                                        let v1507 = constructor_iconcat(ctx, I64, v1491.1, v1483.1);
                                                                                                                        let v1514 = constructor_ult(ctx, v2.0, v1506, v1507);
                                                                                                                        // Rule at src/opts/icmp.isle line 283.
                                                                                                                        returns.extend(Some(v1514));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThanOrEqual => {
                                                                        let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                        let v1486 = C::value_type(ctx, v1483.0);
                                                                        if v1486 == I64 {
                                                                            let v1487 = C::value_type(ctx, v1483.1);
                                                                            if v1487 == I64 {
                                                                                if v2.0 == v1497.0 {
                                                                                    let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                                    if v1483.0 == v1503.0 {
                                                                                        if v1483.1 == v1503.1 {
                                                                                            let mut v89 = C::inst_data_value_etor_returns::default();
                                                                                            C::inst_data_value_etor(ctx, v79.1, &mut v89);
                                                                                            let mut v89 = v89.into_context_iter();
                                                                                            while let Some(v90) = v89.next(ctx) {
                                                                                                if let &InstructionData::IntCompare {
                                                                                                    opcode: ref v1488,
                                                                                                    args: ref v1489,
                                                                                                    cond: ref v1490,
                                                                                                } = &v90.1 {
                                                                                                    if let &Opcode::Icmp = v1488 {
                                                                                                        if let &IntCC::UnsignedLessThanOrEqual = v1490 {
                                                                                                            let v1491 = C::unpack_value_array_2(ctx, v1489);
                                                                                                            let v1494 = C::value_type(ctx, v1491.0);
                                                                                                            if v1494 == I64 {
                                                                                                                let v1495 = C::value_type(ctx, v1491.1);
                                                                                                                if v1495 == I64 {
                                                                                                                    if v2.0 == v90.0 {
                                                                                                                        let v1506 = constructor_iconcat(ctx, I64, v1491.0, v1483.0);
                                                                                                                        let v1507 = constructor_iconcat(ctx, I64, v1491.1, v1483.1);
                                                                                                                        let v1512 = constructor_ule(ctx, v2.0, v1506, v1507);
                                                                                                                        // Rule at src/opts/icmp.isle line 273.
                                                                                                                        returns.extend(Some(v1512));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::Ternary {
                                                            opcode: ref v1692,
                                                            args: ref v1693,
                                                        } => {
                                                            if let &Opcode::Select = v1692 {
                                                                if v2.0 == v1497.0 {
                                                                    let mut v1624 = C::inst_data_value_tupled_etor_returns::default();
                                                                    C::inst_data_value_tupled_etor(ctx, v79.1, &mut v1624);
                                                                    let mut v1624 = v1624.into_context_iter();
                                                                    while let Some(v1625) = v1624.next(ctx) {
                                                                        let v1626 = C::iconst_sextend_etor(ctx, v1625);
                                                                        if let Some(v1627) = v1626 {
                                                                            if v1627.1 == 0_i64 {
                                                                                if v2.0 == v1627.0 {
                                                                                    let v1694 = C::unpack_value_array_3(ctx, v1693);
                                                                                    let mut v1925 = C::inst_data_value_etor_returns::default();
                                                                                    C::inst_data_value_etor(ctx, v1694.0, &mut v1925);
                                                                                    let mut v1925 = v1925.into_context_iter();
                                                                                    while let Some(v1926) = v1925.next(ctx) {
                                                                                        if let &InstructionData::IntCompare {
                                                                                            opcode: ref v1929,
                                                                                            args: ref v1930,
                                                                                            cond: ref v1931,
                                                                                        } = &v1926.1 {
                                                                                            if let &Opcode::Icmp = v1929 {
                                                                                                match v1931 {
                                                                                                    &IntCC::SignedGreaterThan => {
                                                                                                        if v84.0 == v1926.0 {
                                                                                                            let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                                                            let v1932 = C::unpack_value_array_2(ctx, v1930);
                                                                                                            if v1483.0 == v1932.0 {
                                                                                                                if v1483.1 == v1932.1 {
                                                                                                                    let mut v1935 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1694.1, &mut v1935);
                                                                                                                    let mut v1935 = v1935.into_context_iter();
                                                                                                                    while let Some(v1936) = v1935.next(ctx) {
                                                                                                                        let v1937 = C::iconst_sextend_etor(ctx, v1936);
                                                                                                                        if let Some(v1938) = v1937 {
                                                                                                                            if v1938.1 == 1_i64 {
                                                                                                                                if v2.0 == v1938.0 {
                                                                                                                                    let mut v1941 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1694.2, &mut v1941);
                                                                                                                                    let mut v1941 = v1941.into_context_iter();
                                                                                                                                    while let Some(v1942) = v1941.next(ctx) {
                                                                                                                                        let v1943 = C::iconst_sextend_etor(ctx, v1942);
                                                                                                                                        if let Some(v1944) = v1943 {
                                                                                                                                            if v1944.1 == -1_i64 {
                                                                                                                                                if v2.0 == v1944.0 {
                                                                                                                                                    let v1957 = constructor_spaceship_s(ctx, v84.0, v1483.0, v1483.1);
                                                                                                                                                    let v1958 = constructor_sextend_maybe(ctx, v2.0, v1957);
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 103.
                                                                                                                                                    returns.extend(Some(v1958));
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    &IntCC::SignedGreaterThanOrEqual => {
                                                                                                        if v84.0 == v1926.0 {
                                                                                                            let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                                                            let v1932 = C::unpack_value_array_2(ctx, v1930);
                                                                                                            if v1483.0 == v1932.0 {
                                                                                                                if v1483.1 == v1932.1 {
                                                                                                                    let mut v1935 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1694.1, &mut v1935);
                                                                                                                    let mut v1935 = v1935.into_context_iter();
                                                                                                                    while let Some(v1936) = v1935.next(ctx) {
                                                                                                                        let v1937 = C::iconst_sextend_etor(ctx, v1936);
                                                                                                                        if let Some(v1938) = v1937 {
                                                                                                                            if v1938.1 == 1_i64 {
                                                                                                                                if v2.0 == v1938.0 {
                                                                                                                                    let mut v1941 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1694.2, &mut v1941);
                                                                                                                                    let mut v1941 = v1941.into_context_iter();
                                                                                                                                    while let Some(v1942) = v1941.next(ctx) {
                                                                                                                                        let v1943 = C::iconst_sextend_etor(ctx, v1942);
                                                                                                                                        if let Some(v1944) = v1943 {
                                                                                                                                            if v1944.1 == -1_i64 {
                                                                                                                                                if v2.0 == v1944.0 {
                                                                                                                                                    let v1957 = constructor_spaceship_s(ctx, v84.0, v1483.0, v1483.1);
                                                                                                                                                    let v1958 = constructor_sextend_maybe(ctx, v2.0, v1957);
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 110.
                                                                                                                                                    returns.extend(Some(v1958));
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    &IntCC::SignedLessThan => {
                                                                                                        if v84.0 == v1926.0 {
                                                                                                            let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                                                            let v1932 = C::unpack_value_array_2(ctx, v1930);
                                                                                                            if v1483.0 == v1932.0 {
                                                                                                                if v1483.1 == v1932.1 {
                                                                                                                    let mut v1935 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1694.1, &mut v1935);
                                                                                                                    let mut v1935 = v1935.into_context_iter();
                                                                                                                    while let Some(v1936) = v1935.next(ctx) {
                                                                                                                        let v1937 = C::iconst_sextend_etor(ctx, v1936);
                                                                                                                        if let Some(v1938) = v1937 {
                                                                                                                            if v1938.1 == -1_i64 {
                                                                                                                                if v2.0 == v1938.0 {
                                                                                                                                    let mut v1941 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1694.2, &mut v1941);
                                                                                                                                    let mut v1941 = v1941.into_context_iter();
                                                                                                                                    while let Some(v1942) = v1941.next(ctx) {
                                                                                                                                        let v1943 = C::iconst_sextend_etor(ctx, v1942);
                                                                                                                                        if let Some(v1944) = v1943 {
                                                                                                                                            if v1944.1 == 1_i64 {
                                                                                                                                                if v2.0 == v1944.0 {
                                                                                                                                                    let v1957 = constructor_spaceship_s(ctx, v84.0, v1483.0, v1483.1);
                                                                                                                                                    let v1958 = constructor_sextend_maybe(ctx, v2.0, v1957);
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 89.
                                                                                                                                                    returns.extend(Some(v1958));
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    &IntCC::SignedLessThanOrEqual => {
                                                                                                        if v84.0 == v1926.0 {
                                                                                                            let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                                                            let v1932 = C::unpack_value_array_2(ctx, v1930);
                                                                                                            if v1483.0 == v1932.0 {
                                                                                                                if v1483.1 == v1932.1 {
                                                                                                                    let mut v1935 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1694.1, &mut v1935);
                                                                                                                    let mut v1935 = v1935.into_context_iter();
                                                                                                                    while let Some(v1936) = v1935.next(ctx) {
                                                                                                                        let v1937 = C::iconst_sextend_etor(ctx, v1936);
                                                                                                                        if let Some(v1938) = v1937 {
                                                                                                                            if v1938.1 == -1_i64 {
                                                                                                                                if v2.0 == v1938.0 {
                                                                                                                                    let mut v1941 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1694.2, &mut v1941);
                                                                                                                                    let mut v1941 = v1941.into_context_iter();
                                                                                                                                    while let Some(v1942) = v1941.next(ctx) {
                                                                                                                                        let v1943 = C::iconst_sextend_etor(ctx, v1942);
                                                                                                                                        if let Some(v1944) = v1943 {
                                                                                                                                            if v1944.1 == 1_i64 {
                                                                                                                                                if v2.0 == v1944.0 {
                                                                                                                                                    let v1957 = constructor_spaceship_s(ctx, v84.0, v1483.0, v1483.1);
                                                                                                                                                    let v1958 = constructor_sextend_maybe(ctx, v2.0, v1957);
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 96.
                                                                                                                                                    returns.extend(Some(v1958));
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    &IntCC::UnsignedGreaterThan => {
                                                                                                        if v84.0 == v1926.0 {
                                                                                                            let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                                                            let v1932 = C::unpack_value_array_2(ctx, v1930);
                                                                                                            if v1483.0 == v1932.0 {
                                                                                                                if v1483.1 == v1932.1 {
                                                                                                                    let mut v1935 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1694.1, &mut v1935);
                                                                                                                    let mut v1935 = v1935.into_context_iter();
                                                                                                                    while let Some(v1936) = v1935.next(ctx) {
                                                                                                                        let v1937 = C::iconst_sextend_etor(ctx, v1936);
                                                                                                                        if let Some(v1938) = v1937 {
                                                                                                                            if v1938.1 == 1_i64 {
                                                                                                                                if v2.0 == v1938.0 {
                                                                                                                                    let mut v1941 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1694.2, &mut v1941);
                                                                                                                                    let mut v1941 = v1941.into_context_iter();
                                                                                                                                    while let Some(v1942) = v1941.next(ctx) {
                                                                                                                                        let v1943 = C::iconst_sextend_etor(ctx, v1942);
                                                                                                                                        if let Some(v1944) = v1943 {
                                                                                                                                            if v1944.1 == -1_i64 {
                                                                                                                                                if v2.0 == v1944.0 {
                                                                                                                                                    let v1923 = constructor_spaceship_u(ctx, v84.0, v1483.0, v1483.1);
                                                                                                                                                    let v1924 = constructor_sextend_maybe(ctx, v2.0, v1923);
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 38.
                                                                                                                                                    returns.extend(Some(v1924));
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    &IntCC::UnsignedGreaterThanOrEqual => {
                                                                                                        if v84.0 == v1926.0 {
                                                                                                            let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                                                            let v1932 = C::unpack_value_array_2(ctx, v1930);
                                                                                                            if v1483.0 == v1932.0 {
                                                                                                                if v1483.1 == v1932.1 {
                                                                                                                    let mut v1935 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1694.1, &mut v1935);
                                                                                                                    let mut v1935 = v1935.into_context_iter();
                                                                                                                    while let Some(v1936) = v1935.next(ctx) {
                                                                                                                        let v1937 = C::iconst_sextend_etor(ctx, v1936);
                                                                                                                        if let Some(v1938) = v1937 {
                                                                                                                            if v1938.1 == 1_i64 {
                                                                                                                                if v2.0 == v1938.0 {
                                                                                                                                    let mut v1941 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1694.2, &mut v1941);
                                                                                                                                    let mut v1941 = v1941.into_context_iter();
                                                                                                                                    while let Some(v1942) = v1941.next(ctx) {
                                                                                                                                        let v1943 = C::iconst_sextend_etor(ctx, v1942);
                                                                                                                                        if let Some(v1944) = v1943 {
                                                                                                                                            if v1944.1 == -1_i64 {
                                                                                                                                                if v2.0 == v1944.0 {
                                                                                                                                                    let v1923 = constructor_spaceship_u(ctx, v84.0, v1483.0, v1483.1);
                                                                                                                                                    let v1924 = constructor_sextend_maybe(ctx, v2.0, v1923);
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 45.
                                                                                                                                                    returns.extend(Some(v1924));
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    &IntCC::UnsignedLessThan => {
                                                                                                        if v84.0 == v1926.0 {
                                                                                                            let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                                                            let v1932 = C::unpack_value_array_2(ctx, v1930);
                                                                                                            if v1483.0 == v1932.0 {
                                                                                                                if v1483.1 == v1932.1 {
                                                                                                                    let mut v1935 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1694.1, &mut v1935);
                                                                                                                    let mut v1935 = v1935.into_context_iter();
                                                                                                                    while let Some(v1936) = v1935.next(ctx) {
                                                                                                                        let v1937 = C::iconst_sextend_etor(ctx, v1936);
                                                                                                                        if let Some(v1938) = v1937 {
                                                                                                                            if v1938.1 == -1_i64 {
                                                                                                                                if v2.0 == v1938.0 {
                                                                                                                                    let mut v1941 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1694.2, &mut v1941);
                                                                                                                                    let mut v1941 = v1941.into_context_iter();
                                                                                                                                    while let Some(v1942) = v1941.next(ctx) {
                                                                                                                                        let v1943 = C::iconst_sextend_etor(ctx, v1942);
                                                                                                                                        if let Some(v1944) = v1943 {
                                                                                                                                            if v1944.1 == 1_i64 {
                                                                                                                                                if v2.0 == v1944.0 {
                                                                                                                                                    let v1923 = constructor_spaceship_u(ctx, v84.0, v1483.0, v1483.1);
                                                                                                                                                    let v1924 = constructor_sextend_maybe(ctx, v2.0, v1923);
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 24.
                                                                                                                                                    returns.extend(Some(v1924));
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    &IntCC::UnsignedLessThanOrEqual => {
                                                                                                        if v84.0 == v1926.0 {
                                                                                                            let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                                                            let v1932 = C::unpack_value_array_2(ctx, v1930);
                                                                                                            if v1483.0 == v1932.0 {
                                                                                                                if v1483.1 == v1932.1 {
                                                                                                                    let mut v1935 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1694.1, &mut v1935);
                                                                                                                    let mut v1935 = v1935.into_context_iter();
                                                                                                                    while let Some(v1936) = v1935.next(ctx) {
                                                                                                                        let v1937 = C::iconst_sextend_etor(ctx, v1936);
                                                                                                                        if let Some(v1938) = v1937 {
                                                                                                                            if v1938.1 == -1_i64 {
                                                                                                                                if v2.0 == v1938.0 {
                                                                                                                                    let mut v1941 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1694.2, &mut v1941);
                                                                                                                                    let mut v1941 = v1941.into_context_iter();
                                                                                                                                    while let Some(v1942) = v1941.next(ctx) {
                                                                                                                                        let v1943 = C::iconst_sextend_etor(ctx, v1942);
                                                                                                                                        if let Some(v1944) = v1943 {
                                                                                                                                            if v1944.1 == 1_i64 {
                                                                                                                                                if v2.0 == v1944.0 {
                                                                                                                                                    let v1923 = constructor_spaceship_u(ctx, v84.0, v1483.0, v1483.1);
                                                                                                                                                    let v1924 = constructor_sextend_maybe(ctx, v2.0, v1923);
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 31.
                                                                                                                                                    returns.extend(Some(v1924));
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    _ => {}
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                if v79.1 == v1483.0 {
                                                    if v79.2 == v1483.1 {
                                                        let v1707 = C::subsume(ctx, v1483.1);
                                                        // Rule at src/opts/selects.isle line 116.
                                                        returns.extend(Some(v1707));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v79.2 == v1483.0 {
                                                    if v79.1 == v1483.1 {
                                                        let v1708 = C::subsume(ctx, v1483.0);
                                                        // Rule at src/opts/selects.isle line 118.
                                                        returns.extend(Some(v1708));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::NotEqual => {
                                                let mut v89 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v79.1, &mut v89);
                                                let mut v89 = v89.into_context_iter();
                                                while let Some(v90) = v89.next(ctx) {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v1744,
                                                        args: ref v1745,
                                                    } = &v90.1 {
                                                        match v1744 {
                                                            &Opcode::Isub => {
                                                                if v2.0 == v90.0 {
                                                                    let mut v1496 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v79.2, &mut v1496);
                                                                    let mut v1496 = v1496.into_context_iter();
                                                                    while let Some(v1497) = v1496.next(ctx) {
                                                                        if let &InstructionData::Binary {
                                                                            opcode: ref v1738,
                                                                            args: ref v1739,
                                                                        } = &v1497.1 {
                                                                            if let &Opcode::Isub = v1738 {
                                                                                if v2.0 == v1497.0 {
                                                                                    let v1740 = C::unpack_value_array_2(ctx, v1739);
                                                                                    let v1746 = C::unpack_value_array_2(ctx, v1745);
                                                                                    if v1740.0 == v1746.0 {
                                                                                        let mut v1766 = C::inst_data_value_etor_returns::default();
                                                                                        C::inst_data_value_etor(ctx, v1740.1, &mut v1766);
                                                                                        let mut v1766 = v1766.into_context_iter();
                                                                                        while let Some(v1767) = v1766.next(ctx) {
                                                                                            if let &InstructionData::UnaryImm {
                                                                                                opcode: ref v1770,
                                                                                                imm: v1771,
                                                                                            } = &v1767.1 {
                                                                                                if let &Opcode::Iconst = v1770 {
                                                                                                    if v2.0 == v1767.0 {
                                                                                                        let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                                                        if v1483.0 == v1746.1 {
                                                                                                            let mut v1660 = C::inst_data_value_etor_returns::default();
                                                                                                            C::inst_data_value_etor(ctx, v1483.1, &mut v1660);
                                                                                                            let mut v1660 = v1660.into_context_iter();
                                                                                                            while let Some(v1661) = v1660.next(ctx) {
                                                                                                                if let &InstructionData::UnaryImm {
                                                                                                                    opcode: ref v1664,
                                                                                                                    imm: v1665,
                                                                                                                } = &v1661.1 {
                                                                                                                    if let &Opcode::Iconst = v1664 {
                                                                                                                        if v2.0 == v1661.0 {
                                                                                                                            let v1666 = C::u64_from_imm64(ctx, v1665);
                                                                                                                            let v1772 = C::u64_from_imm64(ctx, v1771);
                                                                                                                            if v1666 == v1772 {
                                                                                                                                let v1765 = constructor_isub(ctx, v2.0, v1746.0, v1483.0);
                                                                                                                                // Rule at src/opts/selects.isle line 186.
                                                                                                                                returns.extend(Some(v1765));
                                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                        if v1483.1 == v1746.1 {
                                                                                                            let mut v1773 = C::inst_data_value_etor_returns::default();
                                                                                                            C::inst_data_value_etor(ctx, v1483.0, &mut v1773);
                                                                                                            let mut v1773 = v1773.into_context_iter();
                                                                                                            while let Some(v1774) = v1773.next(ctx) {
                                                                                                                if let &InstructionData::UnaryImm {
                                                                                                                    opcode: ref v1777,
                                                                                                                    imm: v1778,
                                                                                                                } = &v1774.1 {
                                                                                                                    if let &Opcode::Iconst = v1777 {
                                                                                                                        if v2.0 == v1774.0 {
                                                                                                                            let v1772 = C::u64_from_imm64(ctx, v1771);
                                                                                                                            let v1779 = C::u64_from_imm64(ctx, v1778);
                                                                                                                            if v1772 == v1779 {
                                                                                                                                let v1780 = constructor_isub(ctx, v2.0, v1746.0, v1483.1);
                                                                                                                                // Rule at src/opts/selects.isle line 188.
                                                                                                                                returns.extend(Some(v1780));
                                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Band => {
                                                                if v2.0 == v90.0 {
                                                                    let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                    if v79.2 == v1483.0 {
                                                                        let v1746 = C::unpack_value_array_2(ctx, v1745);
                                                                        if v79.2 == v1746.0 {
                                                                            if v1483.1 == v1746.1 {
                                                                                let v1751 = constructor_band(ctx, v2.0, v1483.1, v1483.0);
                                                                                // Rule at src/opts/selects.isle line 146.
                                                                                returns.extend(Some(v1751));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                        if v79.2 == v1746.1 {
                                                                            if v1483.1 == v1746.0 {
                                                                                let v1751 = constructor_band(ctx, v2.0, v1483.1, v1483.0);
                                                                                // Rule at src/opts/selects.isle line 144.
                                                                                returns.extend(Some(v1751));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                    if v79.2 == v1483.1 {
                                                                        let v1746 = C::unpack_value_array_2(ctx, v1745);
                                                                        if v79.2 == v1746.0 {
                                                                            if v1483.0 == v1746.1 {
                                                                                let v1750 = constructor_band(ctx, v2.0, v1483.0, v1483.1);
                                                                                // Rule at src/opts/selects.isle line 142.
                                                                                returns.extend(Some(v1750));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                        if v1483.0 == v1746.0 {
                                                                            if v79.2 == v1746.1 {
                                                                                let v1750 = constructor_band(ctx, v2.0, v1483.0, v1483.1);
                                                                                // Rule at src/opts/selects.isle line 140.
                                                                                returns.extend(Some(v1750));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Bor => {
                                                                if v2.0 == v90.0 {
                                                                    let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                    if v79.2 == v1483.0 {
                                                                        let v1746 = C::unpack_value_array_2(ctx, v1745);
                                                                        if v79.2 == v1746.0 {
                                                                            if v1483.1 == v1746.1 {
                                                                                let v1743 = constructor_bor(ctx, v2.0, v1483.0, v1483.1);
                                                                                // Rule at src/opts/selects.isle line 130.
                                                                                returns.extend(Some(v1743));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                        if v79.2 == v1746.1 {
                                                                            if v1483.1 == v1746.0 {
                                                                                let v1743 = constructor_bor(ctx, v2.0, v1483.0, v1483.1);
                                                                                // Rule at src/opts/selects.isle line 132.
                                                                                returns.extend(Some(v1743));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                    if v79.2 == v1483.1 {
                                                                        let v1746 = C::unpack_value_array_2(ctx, v1745);
                                                                        if v79.2 == v1746.0 {
                                                                            if v1483.0 == v1746.1 {
                                                                                let v1749 = constructor_bor(ctx, v2.0, v1483.1, v1483.0);
                                                                                // Rule at src/opts/selects.isle line 134.
                                                                                returns.extend(Some(v1749));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                        if v1483.0 == v1746.0 {
                                                                            if v79.2 == v1746.1 {
                                                                                let v1749 = constructor_bor(ctx, v2.0, v1483.1, v1483.0);
                                                                                // Rule at src/opts/selects.isle line 136.
                                                                                returns.extend(Some(v1749));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                    }
                                                }
                                                let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                if v79.1 == v1483.0 {
                                                    if v79.2 == v1483.1 {
                                                        let v1708 = C::subsume(ctx, v1483.0);
                                                        // Rule at src/opts/selects.isle line 119.
                                                        returns.extend(Some(v1708));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v79.1 == v1483.1 {
                                                    if v79.2 == v1483.0 {
                                                        let v1707 = C::subsume(ctx, v1483.1);
                                                        // Rule at src/opts/selects.isle line 117.
                                                        returns.extend(Some(v1707));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::SignedGreaterThan => {
                                                let mut v1496 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v79.2, &mut v1496);
                                                let mut v1496 = v1496.into_context_iter();
                                                while let Some(v1497) = v1496.next(ctx) {
                                                    match &v1497.1 {
                                                        &InstructionData::IntCompare {
                                                            opcode: ref v1500,
                                                            args: ref v1501,
                                                            cond: ref v1502,
                                                        } => {
                                                            if let &Opcode::Icmp = v1500 {
                                                                match v1502 {
                                                                    &IntCC::SignedGreaterThan => {
                                                                        if v2.0 == v1497.0 {
                                                                            let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                            let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                            if v1483.0 == v1503.1 {
                                                                                if v1483.1 == v1503.0 {
                                                                                    let mut v89 = C::inst_data_value_etor_returns::default();
                                                                                    C::inst_data_value_etor(ctx, v79.1, &mut v89);
                                                                                    let mut v89 = v89.into_context_iter();
                                                                                    while let Some(v90) = v89.next(ctx) {
                                                                                        if let &InstructionData::UnaryImm {
                                                                                            opcode: ref v1612,
                                                                                            imm: v1613,
                                                                                        } = &v90.1 {
                                                                                            if let &Opcode::Iconst = v1612 {
                                                                                                let v1614 = C::u64_from_imm64(ctx, v1613);
                                                                                                if v1614 == 0x1_u64 {
                                                                                                    if v2.0 == v90.0 {
                                                                                                        let v1755 = constructor_ne(ctx, v2.0, v1483.1, v1483.0);
                                                                                                        // Rule at src/opts/selects.isle line 164.
                                                                                                        returns.extend(Some(v1755));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedLessThan => {
                                                                        if v2.0 == v1497.0 {
                                                                            let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                            let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                            if v1483.0 == v1503.0 {
                                                                                if v1483.1 == v1503.1 {
                                                                                    let mut v89 = C::inst_data_value_etor_returns::default();
                                                                                    C::inst_data_value_etor(ctx, v79.1, &mut v89);
                                                                                    let mut v89 = v89.into_context_iter();
                                                                                    while let Some(v90) = v89.next(ctx) {
                                                                                        if let &InstructionData::UnaryImm {
                                                                                            opcode: ref v1612,
                                                                                            imm: v1613,
                                                                                        } = &v90.1 {
                                                                                            if let &Opcode::Iconst = v1612 {
                                                                                                let v1614 = C::u64_from_imm64(ctx, v1613);
                                                                                                if v1614 == 0x1_u64 {
                                                                                                    if v2.0 == v90.0 {
                                                                                                        let v1755 = constructor_ne(ctx, v2.0, v1483.1, v1483.0);
                                                                                                        // Rule at src/opts/selects.isle line 168.
                                                                                                        returns.extend(Some(v1755));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v1654,
                                                            arg: v1655,
                                                        } => {
                                                            match v1654 {
                                                                &Opcode::Ineg => {
                                                                    if v84.0 == v1497.0 {
                                                                        let mut v1624 = C::inst_data_value_tupled_etor_returns::default();
                                                                        C::inst_data_value_tupled_etor(ctx, v79.1, &mut v1624);
                                                                        let mut v1624 = v1624.into_context_iter();
                                                                        while let Some(v1625) = v1624.next(ctx) {
                                                                            let v1626 = C::iconst_sextend_etor(ctx, v1625);
                                                                            if let Some(v1627) = v1626 {
                                                                                if v1627.1 == 1_i64 {
                                                                                    if v2.0 == v1627.0 {
                                                                                        let mut v1947 = C::inst_data_value_etor_returns::default();
                                                                                        C::inst_data_value_etor(ctx, v1655, &mut v1947);
                                                                                        let mut v1947 = v1947.into_context_iter();
                                                                                        while let Some(v1948) = v1947.next(ctx) {
                                                                                            if let &InstructionData::IntCompare {
                                                                                                opcode: ref v1951,
                                                                                                args: ref v1952,
                                                                                                cond: ref v1953,
                                                                                            } = &v1948.1 {
                                                                                                if let &Opcode::Icmp = v1951 {
                                                                                                    match v1953 {
                                                                                                        &IntCC::NotEqual => {
                                                                                                            if v84.0 == v1948.0 {
                                                                                                                let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                                                                let v1954 = C::unpack_value_array_2(ctx, v1952);
                                                                                                                if v1483.0 == v1954.0 {
                                                                                                                    if v1483.1 == v1954.1 {
                                                                                                                        let v1957 = constructor_spaceship_s(ctx, v84.0, v1483.0, v1483.1);
                                                                                                                        let v1958 = constructor_sextend_maybe(ctx, v2.0, v1957);
                                                                                                                        // Rule at src/opts/spaceship.isle line 129.
                                                                                                                        returns.extend(Some(v1958));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                        &IntCC::SignedLessThan => {
                                                                                                            if v84.0 == v1948.0 {
                                                                                                                let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                                                                let v1954 = C::unpack_value_array_2(ctx, v1952);
                                                                                                                if v1483.0 == v1954.0 {
                                                                                                                    if v1483.1 == v1954.1 {
                                                                                                                        let v1957 = constructor_spaceship_s(ctx, v84.0, v1483.0, v1483.1);
                                                                                                                        let v1958 = constructor_sextend_maybe(ctx, v2.0, v1957);
                                                                                                                        // Rule at src/opts/spaceship.isle line 119.
                                                                                                                        returns.extend(Some(v1958));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                        _ => {}
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    if v2.0 == v1497.0 {
                                                                        let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                        if v79.1 == v1483.0 {
                                                                            if v79.1 == v1655 {
                                                                                let mut v1660 = C::inst_data_value_etor_returns::default();
                                                                                C::inst_data_value_etor(ctx, v1483.1, &mut v1660);
                                                                                let mut v1660 = v1660.into_context_iter();
                                                                                while let Some(v1661) = v1660.next(ctx) {
                                                                                    if let &InstructionData::UnaryImm {
                                                                                        opcode: ref v1664,
                                                                                        imm: v1665,
                                                                                    } = &v1661.1 {
                                                                                        if let &Opcode::Iconst = v1664 {
                                                                                            let v1666 = C::u64_from_imm64(ctx, v1665);
                                                                                            if v1666 == 0x0_u64 {
                                                                                                if v2.0 == v1661.0 {
                                                                                                    let v1667 = constructor_iabs(ctx, v2.0, v1483.0);
                                                                                                    let v1668 = C::subsume(ctx, v1667);
                                                                                                    // Rule at src/opts/selects.isle line 89.
                                                                                                    returns.extend(Some(v1668));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Bmask => {
                                                                    if v2.0 == v1497.0 {
                                                                        let mut v1624 = C::inst_data_value_tupled_etor_returns::default();
                                                                        C::inst_data_value_tupled_etor(ctx, v79.1, &mut v1624);
                                                                        let mut v1624 = v1624.into_context_iter();
                                                                        while let Some(v1625) = v1624.next(ctx) {
                                                                            let v1626 = C::iconst_sextend_etor(ctx, v1625);
                                                                            if let Some(v1627) = v1626 {
                                                                                if v1627.1 == 1_i64 {
                                                                                    if v2.0 == v1627.0 {
                                                                                        let mut v1947 = C::inst_data_value_etor_returns::default();
                                                                                        C::inst_data_value_etor(ctx, v1655, &mut v1947);
                                                                                        let mut v1947 = v1947.into_context_iter();
                                                                                        while let Some(v1948) = v1947.next(ctx) {
                                                                                            if let &InstructionData::IntCompare {
                                                                                                opcode: ref v1951,
                                                                                                args: ref v1952,
                                                                                                cond: ref v1953,
                                                                                            } = &v1948.1 {
                                                                                                if let &Opcode::Icmp = v1951 {
                                                                                                    match v1953 {
                                                                                                        &IntCC::NotEqual => {
                                                                                                            if v84.0 == v1948.0 {
                                                                                                                let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                                                                let v1954 = C::unpack_value_array_2(ctx, v1952);
                                                                                                                if v1483.0 == v1954.0 {
                                                                                                                    if v1483.1 == v1954.1 {
                                                                                                                        let v1957 = constructor_spaceship_s(ctx, v84.0, v1483.0, v1483.1);
                                                                                                                        let v1958 = constructor_sextend_maybe(ctx, v2.0, v1957);
                                                                                                                        // Rule at src/opts/spaceship.isle line 133.
                                                                                                                        returns.extend(Some(v1958));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                        &IntCC::SignedLessThan => {
                                                                                                            if v84.0 == v1948.0 {
                                                                                                                let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                                                                let v1954 = C::unpack_value_array_2(ctx, v1952);
                                                                                                                if v1483.0 == v1954.0 {
                                                                                                                    if v1483.1 == v1954.1 {
                                                                                                                        let v1957 = constructor_spaceship_s(ctx, v84.0, v1483.0, v1483.1);
                                                                                                                        let v1958 = constructor_sextend_maybe(ctx, v2.0, v1957);
                                                                                                                        // Rule at src/opts/spaceship.isle line 123.
                                                                                                                        returns.extend(Some(v1958));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                        _ => {}
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                if v79.1 == v1483.0 {
                                                    if v79.2 == v1483.1 {
                                                        let v1637 = constructor_smax(ctx, v2.0, v1483.0, v1483.1);
                                                        // Rule at src/opts/selects.isle line 25.
                                                        returns.extend(Some(v1637));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v79.2 == v1483.0 {
                                                    if v79.1 == v1483.1 {
                                                        let v1639 = constructor_smin(ctx, v2.0, v1483.0, v1483.1);
                                                        // Rule at src/opts/selects.isle line 39.
                                                        returns.extend(Some(v1639));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::SignedGreaterThanOrEqual => {
                                                let mut v1496 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v79.2, &mut v1496);
                                                let mut v1496 = v1496.into_context_iter();
                                                while let Some(v1497) = v1496.next(ctx) {
                                                    match &v1497.1 {
                                                        &InstructionData::Unary {
                                                            opcode: ref v1654,
                                                            arg: v1655,
                                                        } => {
                                                            if let &Opcode::Ineg = v1654 {
                                                                if v2.0 == v1497.0 {
                                                                    let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                    if v79.1 == v1483.0 {
                                                                        if v79.1 == v1655 {
                                                                            let mut v1660 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v1483.1, &mut v1660);
                                                                            let mut v1660 = v1660.into_context_iter();
                                                                            while let Some(v1661) = v1660.next(ctx) {
                                                                                if let &InstructionData::UnaryImm {
                                                                                    opcode: ref v1664,
                                                                                    imm: v1665,
                                                                                } = &v1661.1 {
                                                                                    if let &Opcode::Iconst = v1664 {
                                                                                        let v1666 = C::u64_from_imm64(ctx, v1665);
                                                                                        if v1666 == 0x0_u64 {
                                                                                            if v2.0 == v1661.0 {
                                                                                                let v1667 = constructor_iabs(ctx, v2.0, v1483.0);
                                                                                                let v1668 = C::subsume(ctx, v1667);
                                                                                                // Rule at src/opts/selects.isle line 90.
                                                                                                returns.extend(Some(v1668));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::UnaryImm {
                                                            opcode: ref v1615,
                                                            imm: v1616,
                                                        } => {
                                                            if let &Opcode::Iconst = v1615 {
                                                                let v1617 = C::u64_from_imm64(ctx, v1616);
                                                                if v1617 == 0x1_u64 {
                                                                    if v2.0 == v1497.0 {
                                                                        let mut v89 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v79.1, &mut v89);
                                                                        let mut v89 = v89.into_context_iter();
                                                                        while let Some(v90) = v89.next(ctx) {
                                                                            if let &InstructionData::IntCompare {
                                                                                opcode: ref v1488,
                                                                                args: ref v1489,
                                                                                cond: ref v1490,
                                                                            } = &v90.1 {
                                                                                if let &Opcode::Icmp = v1488 {
                                                                                    match v1490 {
                                                                                        &IntCC::SignedGreaterThan => {
                                                                                            if v2.0 == v90.0 {
                                                                                                let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                                                let v1491 = C::unpack_value_array_2(ctx, v1489);
                                                                                                if v1483.0 == v1491.0 {
                                                                                                    if v1483.1 == v1491.1 {
                                                                                                        let v1754 = constructor_ne(ctx, v2.0, v1483.0, v1483.1);
                                                                                                        // Rule at src/opts/selects.isle line 163.
                                                                                                        returns.extend(Some(v1754));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                        &IntCC::SignedLessThan => {
                                                                                            if v2.0 == v90.0 {
                                                                                                let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                                                let v1491 = C::unpack_value_array_2(ctx, v1489);
                                                                                                if v1483.0 == v1491.1 {
                                                                                                    if v1483.1 == v1491.0 {
                                                                                                        let v1754 = constructor_ne(ctx, v2.0, v1483.0, v1483.1);
                                                                                                        // Rule at src/opts/selects.isle line 167.
                                                                                                        returns.extend(Some(v1754));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                        _ => {}
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                if v79.1 == v1483.0 {
                                                    if v79.2 == v1483.1 {
                                                        let v1637 = constructor_smax(ctx, v2.0, v1483.0, v1483.1);
                                                        // Rule at src/opts/selects.isle line 26.
                                                        returns.extend(Some(v1637));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v79.2 == v1483.0 {
                                                    if v79.1 == v1483.1 {
                                                        let v1639 = constructor_smin(ctx, v2.0, v1483.0, v1483.1);
                                                        // Rule at src/opts/selects.isle line 40.
                                                        returns.extend(Some(v1639));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::SignedLessThan => {
                                                let mut v89 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v79.1, &mut v89);
                                                let mut v89 = v89.into_context_iter();
                                                while let Some(v90) = v89.next(ctx) {
                                                    match &v90.1 {
                                                        &InstructionData::Unary {
                                                            opcode: ref v93,
                                                            arg: v94,
                                                        } => {
                                                            if let &Opcode::Ineg = v93 {
                                                                if v2.0 == v90.0 {
                                                                    if v79.2 == v94 {
                                                                        let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                        if v79.2 == v1483.0 {
                                                                            let mut v1660 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v1483.1, &mut v1660);
                                                                            let mut v1660 = v1660.into_context_iter();
                                                                            while let Some(v1661) = v1660.next(ctx) {
                                                                                if let &InstructionData::UnaryImm {
                                                                                    opcode: ref v1664,
                                                                                    imm: v1665,
                                                                                } = &v1661.1 {
                                                                                    if let &Opcode::Iconst = v1664 {
                                                                                        let v1666 = C::u64_from_imm64(ctx, v1665);
                                                                                        if v1666 == 0x0_u64 {
                                                                                            if v2.0 == v1661.0 {
                                                                                                let v1667 = constructor_iabs(ctx, v2.0, v1483.0);
                                                                                                let v1668 = C::subsume(ctx, v1667);
                                                                                                // Rule at src/opts/selects.isle line 92.
                                                                                                returns.extend(Some(v1668));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::UnaryImm {
                                                            opcode: ref v1612,
                                                            imm: v1613,
                                                        } => {
                                                            if let &Opcode::Iconst = v1612 {
                                                                let v1614 = C::u64_from_imm64(ctx, v1613);
                                                                if v1614 == 0x1_u64 {
                                                                    if v2.0 == v90.0 {
                                                                        let mut v1496 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v79.2, &mut v1496);
                                                                        let mut v1496 = v1496.into_context_iter();
                                                                        while let Some(v1497) = v1496.next(ctx) {
                                                                            if let &InstructionData::IntCompare {
                                                                                opcode: ref v1500,
                                                                                args: ref v1501,
                                                                                cond: ref v1502,
                                                                            } = &v1497.1 {
                                                                                if let &Opcode::Icmp = v1500 {
                                                                                    match v1502 {
                                                                                        &IntCC::SignedGreaterThan => {
                                                                                            if v2.0 == v1497.0 {
                                                                                                let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                                                let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                                                if v1483.0 == v1503.0 {
                                                                                                    if v1483.1 == v1503.1 {
                                                                                                        let v1754 = constructor_ne(ctx, v2.0, v1483.0, v1483.1);
                                                                                                        // Rule at src/opts/selects.isle line 162.
                                                                                                        returns.extend(Some(v1754));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                        &IntCC::SignedLessThan => {
                                                                                            if v2.0 == v1497.0 {
                                                                                                let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                                                let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                                                if v1483.0 == v1503.1 {
                                                                                                    if v1483.1 == v1503.0 {
                                                                                                        let v1754 = constructor_ne(ctx, v2.0, v1483.0, v1483.1);
                                                                                                        // Rule at src/opts/selects.isle line 166.
                                                                                                        returns.extend(Some(v1754));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                        _ => {}
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let mut v1624 = C::inst_data_value_tupled_etor_returns::default();
                                                C::inst_data_value_tupled_etor(ctx, v79.1, &mut v1624);
                                                let mut v1624 = v1624.into_context_iter();
                                                while let Some(v1625) = v1624.next(ctx) {
                                                    let v1626 = C::iconst_sextend_etor(ctx, v1625);
                                                    if let Some(v1627) = v1626 {
                                                        if v1627.1 == -1_i64 {
                                                            if v2.0 == v1627.0 {
                                                                let mut v1909 = C::uextend_maybe_etor_returns::default();
                                                                C::uextend_maybe_etor(ctx, v79.2, &mut v1909);
                                                                let mut v1909 = v1909.into_context_iter();
                                                                while let Some(v1910) = v1909.next(ctx) {
                                                                    if v2.0 == v1910.0 {
                                                                        let mut v1913 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v1910.1, &mut v1913);
                                                                        let mut v1913 = v1913.into_context_iter();
                                                                        while let Some(v1914) = v1913.next(ctx) {
                                                                            if let &InstructionData::IntCompare {
                                                                                opcode: ref v1917,
                                                                                args: ref v1918,
                                                                                cond: ref v1919,
                                                                            } = &v1914.1 {
                                                                                if let &Opcode::Icmp = v1917 {
                                                                                    match v1919 {
                                                                                        &IntCC::NotEqual => {
                                                                                            if v84.0 == v1914.0 {
                                                                                                let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                                                let v1920 = C::unpack_value_array_2(ctx, v1918);
                                                                                                if v1483.0 == v1920.0 {
                                                                                                    if v1483.1 == v1920.1 {
                                                                                                        let v1957 = constructor_spaceship_s(ctx, v84.0, v1483.0, v1483.1);
                                                                                                        let v1958 = constructor_sextend_maybe(ctx, v2.0, v1957);
                                                                                                        // Rule at src/opts/spaceship.isle line 77.
                                                                                                        returns.extend(Some(v1958));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                        &IntCC::SignedGreaterThan => {
                                                                                            if v84.0 == v1914.0 {
                                                                                                let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                                                let v1920 = C::unpack_value_array_2(ctx, v1918);
                                                                                                if v1483.0 == v1920.0 {
                                                                                                    if v1483.1 == v1920.1 {
                                                                                                        let v1957 = constructor_spaceship_s(ctx, v84.0, v1483.0, v1483.1);
                                                                                                        let v1958 = constructor_sextend_maybe(ctx, v2.0, v1957);
                                                                                                        // Rule at src/opts/spaceship.isle line 83.
                                                                                                        returns.extend(Some(v1958));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                        _ => {}
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                if v79.1 == v1483.0 {
                                                    if v79.2 == v1483.1 {
                                                        let v1639 = constructor_smin(ctx, v2.0, v1483.0, v1483.1);
                                                        // Rule at src/opts/selects.isle line 29.
                                                        returns.extend(Some(v1639));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v79.1 == v1483.1 {
                                                    if v79.2 == v1483.0 {
                                                        let v1637 = constructor_smax(ctx, v2.0, v1483.0, v1483.1);
                                                        // Rule at src/opts/selects.isle line 35.
                                                        returns.extend(Some(v1637));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::SignedLessThanOrEqual => {
                                                let mut v89 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v79.1, &mut v89);
                                                let mut v89 = v89.into_context_iter();
                                                while let Some(v90) = v89.next(ctx) {
                                                    match &v90.1 {
                                                        &InstructionData::IntCompare {
                                                            opcode: ref v1488,
                                                            args: ref v1489,
                                                            cond: ref v1490,
                                                        } => {
                                                            if let &Opcode::Icmp = v1488 {
                                                                match v1490 {
                                                                    &IntCC::SignedGreaterThan => {
                                                                        if v2.0 == v90.0 {
                                                                            let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                            let v1491 = C::unpack_value_array_2(ctx, v1489);
                                                                            if v1483.0 == v1491.1 {
                                                                                if v1483.1 == v1491.0 {
                                                                                    let mut v1496 = C::inst_data_value_etor_returns::default();
                                                                                    C::inst_data_value_etor(ctx, v79.2, &mut v1496);
                                                                                    let mut v1496 = v1496.into_context_iter();
                                                                                    while let Some(v1497) = v1496.next(ctx) {
                                                                                        if let &InstructionData::UnaryImm {
                                                                                            opcode: ref v1615,
                                                                                            imm: v1616,
                                                                                        } = &v1497.1 {
                                                                                            if let &Opcode::Iconst = v1615 {
                                                                                                let v1617 = C::u64_from_imm64(ctx, v1616);
                                                                                                if v1617 == 0x1_u64 {
                                                                                                    if v2.0 == v1497.0 {
                                                                                                        let v1755 = constructor_ne(ctx, v2.0, v1483.1, v1483.0);
                                                                                                        // Rule at src/opts/selects.isle line 165.
                                                                                                        returns.extend(Some(v1755));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedLessThan => {
                                                                        if v2.0 == v90.0 {
                                                                            let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                            let v1491 = C::unpack_value_array_2(ctx, v1489);
                                                                            if v1483.0 == v1491.0 {
                                                                                if v1483.1 == v1491.1 {
                                                                                    let mut v1496 = C::inst_data_value_etor_returns::default();
                                                                                    C::inst_data_value_etor(ctx, v79.2, &mut v1496);
                                                                                    let mut v1496 = v1496.into_context_iter();
                                                                                    while let Some(v1497) = v1496.next(ctx) {
                                                                                        if let &InstructionData::UnaryImm {
                                                                                            opcode: ref v1615,
                                                                                            imm: v1616,
                                                                                        } = &v1497.1 {
                                                                                            if let &Opcode::Iconst = v1615 {
                                                                                                let v1617 = C::u64_from_imm64(ctx, v1616);
                                                                                                if v1617 == 0x1_u64 {
                                                                                                    if v2.0 == v1497.0 {
                                                                                                        let v1755 = constructor_ne(ctx, v2.0, v1483.1, v1483.0);
                                                                                                        // Rule at src/opts/selects.isle line 169.
                                                                                                        returns.extend(Some(v1755));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v93,
                                                            arg: v94,
                                                        } => {
                                                            if let &Opcode::Ineg = v93 {
                                                                if v2.0 == v90.0 {
                                                                    if v79.2 == v94 {
                                                                        let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                        if v79.2 == v1483.0 {
                                                                            let mut v1660 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v1483.1, &mut v1660);
                                                                            let mut v1660 = v1660.into_context_iter();
                                                                            while let Some(v1661) = v1660.next(ctx) {
                                                                                if let &InstructionData::UnaryImm {
                                                                                    opcode: ref v1664,
                                                                                    imm: v1665,
                                                                                } = &v1661.1 {
                                                                                    if let &Opcode::Iconst = v1664 {
                                                                                        let v1666 = C::u64_from_imm64(ctx, v1665);
                                                                                        if v1666 == 0x0_u64 {
                                                                                            if v2.0 == v1661.0 {
                                                                                                let v1667 = constructor_iabs(ctx, v2.0, v1483.0);
                                                                                                let v1668 = C::subsume(ctx, v1667);
                                                                                                // Rule at src/opts/selects.isle line 91.
                                                                                                returns.extend(Some(v1668));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                if v79.1 == v1483.0 {
                                                    if v79.2 == v1483.1 {
                                                        let v1639 = constructor_smin(ctx, v2.0, v1483.0, v1483.1);
                                                        // Rule at src/opts/selects.isle line 30.
                                                        returns.extend(Some(v1639));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v79.1 == v1483.1 {
                                                    if v79.2 == v1483.0 {
                                                        let v1637 = constructor_smax(ctx, v2.0, v1483.0, v1483.1);
                                                        // Rule at src/opts/selects.isle line 36.
                                                        returns.extend(Some(v1637));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::UnsignedGreaterThan => {
                                                let mut v1496 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v79.2, &mut v1496);
                                                let mut v1496 = v1496.into_context_iter();
                                                while let Some(v1497) = v1496.next(ctx) {
                                                    match &v1497.1 {
                                                        &InstructionData::IntCompare {
                                                            opcode: ref v1500,
                                                            args: ref v1501,
                                                            cond: ref v1502,
                                                        } => {
                                                            if let &Opcode::Icmp = v1500 {
                                                                match v1502 {
                                                                    &IntCC::Equal => {
                                                                        if v2.0 == v1497.0 {
                                                                            let mut v89 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v79.1, &mut v89);
                                                                            let mut v89 = v89.into_context_iter();
                                                                            while let Some(v90) = v89.next(ctx) {
                                                                                if let &InstructionData::UnaryImm {
                                                                                    opcode: ref v1612,
                                                                                    imm: v1613,
                                                                                } = &v90.1 {
                                                                                    if let &Opcode::Iconst = v1612 {
                                                                                        let v1614 = C::u64_from_imm64(ctx, v1613);
                                                                                        if v1614 == 0x1_u64 {
                                                                                            if v2.0 == v90.0 {
                                                                                                let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                                                let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                                                if v1483.0 == v1503.0 {
                                                                                                    if v1483.1 == v1503.1 {
                                                                                                        let v1753 = constructor_ule(ctx, v2.0, v1483.1, v1483.0);
                                                                                                        // Rule at src/opts/selects.isle line 157.
                                                                                                        returns.extend(Some(v1753));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                                if v1483.0 == v1503.1 {
                                                                                                    if v1483.1 == v1503.0 {
                                                                                                        let v1753 = constructor_ule(ctx, v2.0, v1483.1, v1483.0);
                                                                                                        // Rule at src/opts/selects.isle line 153.
                                                                                                        returns.extend(Some(v1753));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedGreaterThan => {
                                                                        if v2.0 == v1497.0 {
                                                                            let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                            let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                            if v1483.0 == v1503.1 {
                                                                                if v1483.1 == v1503.0 {
                                                                                    let mut v89 = C::inst_data_value_etor_returns::default();
                                                                                    C::inst_data_value_etor(ctx, v79.1, &mut v89);
                                                                                    let mut v89 = v89.into_context_iter();
                                                                                    while let Some(v90) = v89.next(ctx) {
                                                                                        if let &InstructionData::UnaryImm {
                                                                                            opcode: ref v1612,
                                                                                            imm: v1613,
                                                                                        } = &v90.1 {
                                                                                            if let &Opcode::Iconst = v1612 {
                                                                                                let v1614 = C::u64_from_imm64(ctx, v1613);
                                                                                                if v1614 == 0x1_u64 {
                                                                                                    if v2.0 == v90.0 {
                                                                                                        let v1755 = constructor_ne(ctx, v2.0, v1483.1, v1483.0);
                                                                                                        // Rule at src/opts/selects.isle line 172.
                                                                                                        returns.extend(Some(v1755));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        if v2.0 == v1497.0 {
                                                                            let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                            let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                            if v1483.0 == v1503.0 {
                                                                                if v1483.1 == v1503.1 {
                                                                                    let mut v89 = C::inst_data_value_etor_returns::default();
                                                                                    C::inst_data_value_etor(ctx, v79.1, &mut v89);
                                                                                    let mut v89 = v89.into_context_iter();
                                                                                    while let Some(v90) = v89.next(ctx) {
                                                                                        if let &InstructionData::UnaryImm {
                                                                                            opcode: ref v1612,
                                                                                            imm: v1613,
                                                                                        } = &v90.1 {
                                                                                            if let &Opcode::Iconst = v1612 {
                                                                                                let v1614 = C::u64_from_imm64(ctx, v1613);
                                                                                                if v1614 == 0x1_u64 {
                                                                                                    if v2.0 == v90.0 {
                                                                                                        let v1755 = constructor_ne(ctx, v2.0, v1483.1, v1483.0);
                                                                                                        // Rule at src/opts/selects.isle line 176.
                                                                                                        returns.extend(Some(v1755));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v1654,
                                                            arg: v1655,
                                                        } => {
                                                            match v1654 {
                                                                &Opcode::Ineg => {
                                                                    if v84.0 == v1497.0 {
                                                                        let mut v1624 = C::inst_data_value_tupled_etor_returns::default();
                                                                        C::inst_data_value_tupled_etor(ctx, v79.1, &mut v1624);
                                                                        let mut v1624 = v1624.into_context_iter();
                                                                        while let Some(v1625) = v1624.next(ctx) {
                                                                            let v1626 = C::iconst_sextend_etor(ctx, v1625);
                                                                            if let Some(v1627) = v1626 {
                                                                                if v1627.1 == 1_i64 {
                                                                                    if v2.0 == v1627.0 {
                                                                                        let mut v1947 = C::inst_data_value_etor_returns::default();
                                                                                        C::inst_data_value_etor(ctx, v1655, &mut v1947);
                                                                                        let mut v1947 = v1947.into_context_iter();
                                                                                        while let Some(v1948) = v1947.next(ctx) {
                                                                                            if let &InstructionData::IntCompare {
                                                                                                opcode: ref v1951,
                                                                                                args: ref v1952,
                                                                                                cond: ref v1953,
                                                                                            } = &v1948.1 {
                                                                                                if let &Opcode::Icmp = v1951 {
                                                                                                    match v1953 {
                                                                                                        &IntCC::NotEqual => {
                                                                                                            if v84.0 == v1948.0 {
                                                                                                                let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                                                                let v1954 = C::unpack_value_array_2(ctx, v1952);
                                                                                                                if v1483.0 == v1954.0 {
                                                                                                                    if v1483.1 == v1954.1 {
                                                                                                                        let v1923 = constructor_spaceship_u(ctx, v84.0, v1483.0, v1483.1);
                                                                                                                        let v1924 = constructor_sextend_maybe(ctx, v2.0, v1923);
                                                                                                                        // Rule at src/opts/spaceship.isle line 64.
                                                                                                                        returns.extend(Some(v1924));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                        &IntCC::UnsignedLessThan => {
                                                                                                            if v84.0 == v1948.0 {
                                                                                                                let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                                                                let v1954 = C::unpack_value_array_2(ctx, v1952);
                                                                                                                if v1483.0 == v1954.0 {
                                                                                                                    if v1483.1 == v1954.1 {
                                                                                                                        let v1923 = constructor_spaceship_u(ctx, v84.0, v1483.0, v1483.1);
                                                                                                                        let v1924 = constructor_sextend_maybe(ctx, v2.0, v1923);
                                                                                                                        // Rule at src/opts/spaceship.isle line 54.
                                                                                                                        returns.extend(Some(v1924));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                        _ => {}
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Bmask => {
                                                                    if v2.0 == v1497.0 {
                                                                        let mut v1624 = C::inst_data_value_tupled_etor_returns::default();
                                                                        C::inst_data_value_tupled_etor(ctx, v79.1, &mut v1624);
                                                                        let mut v1624 = v1624.into_context_iter();
                                                                        while let Some(v1625) = v1624.next(ctx) {
                                                                            let v1626 = C::iconst_sextend_etor(ctx, v1625);
                                                                            if let Some(v1627) = v1626 {
                                                                                if v1627.1 == 1_i64 {
                                                                                    if v2.0 == v1627.0 {
                                                                                        let mut v1947 = C::inst_data_value_etor_returns::default();
                                                                                        C::inst_data_value_etor(ctx, v1655, &mut v1947);
                                                                                        let mut v1947 = v1947.into_context_iter();
                                                                                        while let Some(v1948) = v1947.next(ctx) {
                                                                                            if let &InstructionData::IntCompare {
                                                                                                opcode: ref v1951,
                                                                                                args: ref v1952,
                                                                                                cond: ref v1953,
                                                                                            } = &v1948.1 {
                                                                                                if let &Opcode::Icmp = v1951 {
                                                                                                    match v1953 {
                                                                                                        &IntCC::NotEqual => {
                                                                                                            if v84.0 == v1948.0 {
                                                                                                                let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                                                                let v1954 = C::unpack_value_array_2(ctx, v1952);
                                                                                                                if v1483.0 == v1954.0 {
                                                                                                                    if v1483.1 == v1954.1 {
                                                                                                                        let v1923 = constructor_spaceship_u(ctx, v84.0, v1483.0, v1483.1);
                                                                                                                        let v1924 = constructor_sextend_maybe(ctx, v2.0, v1923);
                                                                                                                        // Rule at src/opts/spaceship.isle line 68.
                                                                                                                        returns.extend(Some(v1924));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                        &IntCC::UnsignedLessThan => {
                                                                                                            if v84.0 == v1948.0 {
                                                                                                                let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                                                                let v1954 = C::unpack_value_array_2(ctx, v1952);
                                                                                                                if v1483.0 == v1954.0 {
                                                                                                                    if v1483.1 == v1954.1 {
                                                                                                                        let v1923 = constructor_spaceship_u(ctx, v84.0, v1483.0, v1483.1);
                                                                                                                        let v1924 = constructor_sextend_maybe(ctx, v2.0, v1923);
                                                                                                                        // Rule at src/opts/spaceship.isle line 58.
                                                                                                                        returns.extend(Some(v1924));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                        _ => {}
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                if v79.1 == v1483.0 {
                                                    if v79.2 == v1483.1 {
                                                        let v1638 = constructor_umax(ctx, v2.0, v1483.0, v1483.1);
                                                        // Rule at src/opts/selects.isle line 27.
                                                        returns.extend(Some(v1638));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v79.2 == v1483.0 {
                                                    if v79.1 == v1483.1 {
                                                        let v1640 = constructor_umin(ctx, v2.0, v1483.0, v1483.1);
                                                        // Rule at src/opts/selects.isle line 41.
                                                        returns.extend(Some(v1640));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::UnsignedGreaterThanOrEqual => {
                                                let mut v89 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v79.1, &mut v89);
                                                let mut v89 = v89.into_context_iter();
                                                while let Some(v90) = v89.next(ctx) {
                                                    if let &InstructionData::IntCompare {
                                                        opcode: ref v1488,
                                                        args: ref v1489,
                                                        cond: ref v1490,
                                                    } = &v90.1 {
                                                        if let &Opcode::Icmp = v1488 {
                                                            match v1490 {
                                                                &IntCC::Equal => {
                                                                    if v2.0 == v90.0 {
                                                                        let mut v1496 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v79.2, &mut v1496);
                                                                        let mut v1496 = v1496.into_context_iter();
                                                                        while let Some(v1497) = v1496.next(ctx) {
                                                                            if let &InstructionData::UnaryImm {
                                                                                opcode: ref v1615,
                                                                                imm: v1616,
                                                                            } = &v1497.1 {
                                                                                if let &Opcode::Iconst = v1615 {
                                                                                    let v1617 = C::u64_from_imm64(ctx, v1616);
                                                                                    if v1617 == 0x1_u64 {
                                                                                        if v2.0 == v1497.0 {
                                                                                            let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                                            let v1491 = C::unpack_value_array_2(ctx, v1489);
                                                                                            if v1483.0 == v1491.0 {
                                                                                                if v1483.1 == v1491.1 {
                                                                                                    let v1752 = constructor_ule(ctx, v2.0, v1483.0, v1483.1);
                                                                                                    // Rule at src/opts/selects.isle line 152.
                                                                                                    returns.extend(Some(v1752));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                            if v1483.0 == v1491.1 {
                                                                                                if v1483.1 == v1491.0 {
                                                                                                    let v1752 = constructor_ule(ctx, v2.0, v1483.0, v1483.1);
                                                                                                    // Rule at src/opts/selects.isle line 156.
                                                                                                    returns.extend(Some(v1752));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &IntCC::UnsignedGreaterThan => {
                                                                    if v2.0 == v90.0 {
                                                                        let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                        let v1491 = C::unpack_value_array_2(ctx, v1489);
                                                                        if v1483.0 == v1491.0 {
                                                                            if v1483.1 == v1491.1 {
                                                                                let mut v1496 = C::inst_data_value_etor_returns::default();
                                                                                C::inst_data_value_etor(ctx, v79.2, &mut v1496);
                                                                                let mut v1496 = v1496.into_context_iter();
                                                                                while let Some(v1497) = v1496.next(ctx) {
                                                                                    if let &InstructionData::UnaryImm {
                                                                                        opcode: ref v1615,
                                                                                        imm: v1616,
                                                                                    } = &v1497.1 {
                                                                                        if let &Opcode::Iconst = v1615 {
                                                                                            let v1617 = C::u64_from_imm64(ctx, v1616);
                                                                                            if v1617 == 0x1_u64 {
                                                                                                if v2.0 == v1497.0 {
                                                                                                    let v1754 = constructor_ne(ctx, v2.0, v1483.0, v1483.1);
                                                                                                    // Rule at src/opts/selects.isle line 171.
                                                                                                    returns.extend(Some(v1754));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &IntCC::UnsignedLessThan => {
                                                                    if v2.0 == v90.0 {
                                                                        let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                        let v1491 = C::unpack_value_array_2(ctx, v1489);
                                                                        if v1483.0 == v1491.1 {
                                                                            if v1483.1 == v1491.0 {
                                                                                let mut v1496 = C::inst_data_value_etor_returns::default();
                                                                                C::inst_data_value_etor(ctx, v79.2, &mut v1496);
                                                                                let mut v1496 = v1496.into_context_iter();
                                                                                while let Some(v1497) = v1496.next(ctx) {
                                                                                    if let &InstructionData::UnaryImm {
                                                                                        opcode: ref v1615,
                                                                                        imm: v1616,
                                                                                    } = &v1497.1 {
                                                                                        if let &Opcode::Iconst = v1615 {
                                                                                            let v1617 = C::u64_from_imm64(ctx, v1616);
                                                                                            if v1617 == 0x1_u64 {
                                                                                                if v2.0 == v1497.0 {
                                                                                                    let v1754 = constructor_ne(ctx, v2.0, v1483.0, v1483.1);
                                                                                                    // Rule at src/opts/selects.isle line 175.
                                                                                                    returns.extend(Some(v1754));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                    }
                                                }
                                                let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                if v79.1 == v1483.0 {
                                                    if v79.2 == v1483.1 {
                                                        let v1638 = constructor_umax(ctx, v2.0, v1483.0, v1483.1);
                                                        // Rule at src/opts/selects.isle line 28.
                                                        returns.extend(Some(v1638));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v79.1 == v1483.1 {
                                                    if v79.2 == v1483.0 {
                                                        let v1640 = constructor_umin(ctx, v2.0, v1483.0, v1483.1);
                                                        // Rule at src/opts/selects.isle line 42.
                                                        returns.extend(Some(v1640));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::UnsignedLessThan => {
                                                let mut v89 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v79.1, &mut v89);
                                                let mut v89 = v89.into_context_iter();
                                                while let Some(v90) = v89.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v1612,
                                                        imm: v1613,
                                                    } = &v90.1 {
                                                        if let &Opcode::Iconst = v1612 {
                                                            let v1614 = C::u64_from_imm64(ctx, v1613);
                                                            if v1614 == 0x1_u64 {
                                                                if v2.0 == v90.0 {
                                                                    let mut v1496 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v79.2, &mut v1496);
                                                                    let mut v1496 = v1496.into_context_iter();
                                                                    while let Some(v1497) = v1496.next(ctx) {
                                                                        if let &InstructionData::IntCompare {
                                                                            opcode: ref v1500,
                                                                            args: ref v1501,
                                                                            cond: ref v1502,
                                                                        } = &v1497.1 {
                                                                            if let &Opcode::Icmp = v1500 {
                                                                                match v1502 {
                                                                                    &IntCC::Equal => {
                                                                                        if v2.0 == v1497.0 {
                                                                                            let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                                            let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                                            if v1483.0 == v1503.0 {
                                                                                                if v1483.1 == v1503.1 {
                                                                                                    let v1752 = constructor_ule(ctx, v2.0, v1483.0, v1483.1);
                                                                                                    // Rule at src/opts/selects.isle line 151.
                                                                                                    returns.extend(Some(v1752));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                            if v1483.0 == v1503.1 {
                                                                                                if v1483.1 == v1503.0 {
                                                                                                    let v1752 = constructor_ule(ctx, v2.0, v1483.0, v1483.1);
                                                                                                    // Rule at src/opts/selects.isle line 155.
                                                                                                    returns.extend(Some(v1752));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                    &IntCC::UnsignedGreaterThan => {
                                                                                        if v2.0 == v1497.0 {
                                                                                            let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                                            let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                                            if v1483.0 == v1503.0 {
                                                                                                if v1483.1 == v1503.1 {
                                                                                                    let v1754 = constructor_ne(ctx, v2.0, v1483.0, v1483.1);
                                                                                                    // Rule at src/opts/selects.isle line 170.
                                                                                                    returns.extend(Some(v1754));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                    &IntCC::UnsignedLessThan => {
                                                                                        if v2.0 == v1497.0 {
                                                                                            let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                                            let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                                            if v1483.0 == v1503.1 {
                                                                                                if v1483.1 == v1503.0 {
                                                                                                    let v1754 = constructor_ne(ctx, v2.0, v1483.0, v1483.1);
                                                                                                    // Rule at src/opts/selects.isle line 174.
                                                                                                    returns.extend(Some(v1754));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                    _ => {}
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                let mut v1624 = C::inst_data_value_tupled_etor_returns::default();
                                                C::inst_data_value_tupled_etor(ctx, v79.1, &mut v1624);
                                                let mut v1624 = v1624.into_context_iter();
                                                while let Some(v1625) = v1624.next(ctx) {
                                                    let v1626 = C::iconst_sextend_etor(ctx, v1625);
                                                    if let Some(v1627) = v1626 {
                                                        if v1627.1 == -1_i64 {
                                                            if v2.0 == v1627.0 {
                                                                let mut v1909 = C::uextend_maybe_etor_returns::default();
                                                                C::uextend_maybe_etor(ctx, v79.2, &mut v1909);
                                                                let mut v1909 = v1909.into_context_iter();
                                                                while let Some(v1910) = v1909.next(ctx) {
                                                                    if v2.0 == v1910.0 {
                                                                        let mut v1913 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v1910.1, &mut v1913);
                                                                        let mut v1913 = v1913.into_context_iter();
                                                                        while let Some(v1914) = v1913.next(ctx) {
                                                                            if let &InstructionData::IntCompare {
                                                                                opcode: ref v1917,
                                                                                args: ref v1918,
                                                                                cond: ref v1919,
                                                                            } = &v1914.1 {
                                                                                if let &Opcode::Icmp = v1917 {
                                                                                    match v1919 {
                                                                                        &IntCC::NotEqual => {
                                                                                            if v84.0 == v1914.0 {
                                                                                                let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                                                let v1920 = C::unpack_value_array_2(ctx, v1918);
                                                                                                if v1483.0 == v1920.0 {
                                                                                                    if v1483.1 == v1920.1 {
                                                                                                        let v1923 = constructor_spaceship_u(ctx, v84.0, v1483.0, v1483.1);
                                                                                                        let v1924 = constructor_sextend_maybe(ctx, v2.0, v1923);
                                                                                                        // Rule at src/opts/spaceship.isle line 12.
                                                                                                        returns.extend(Some(v1924));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                        &IntCC::UnsignedGreaterThan => {
                                                                                            if v84.0 == v1914.0 {
                                                                                                let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                                                let v1920 = C::unpack_value_array_2(ctx, v1918);
                                                                                                if v1483.0 == v1920.0 {
                                                                                                    if v1483.1 == v1920.1 {
                                                                                                        let v1923 = constructor_spaceship_u(ctx, v84.0, v1483.0, v1483.1);
                                                                                                        let v1924 = constructor_sextend_maybe(ctx, v2.0, v1923);
                                                                                                        // Rule at src/opts/spaceship.isle line 18.
                                                                                                        returns.extend(Some(v1924));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                        _ => {}
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                if v79.1 == v1483.0 {
                                                    if v79.2 == v1483.1 {
                                                        let v1640 = constructor_umin(ctx, v2.0, v1483.0, v1483.1);
                                                        // Rule at src/opts/selects.isle line 31.
                                                        returns.extend(Some(v1640));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v79.1 == v1483.1 {
                                                    if v79.2 == v1483.0 {
                                                        let v1638 = constructor_umax(ctx, v2.0, v1483.0, v1483.1);
                                                        // Rule at src/opts/selects.isle line 37.
                                                        returns.extend(Some(v1638));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::UnsignedLessThanOrEqual => {
                                                let mut v89 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v79.1, &mut v89);
                                                let mut v89 = v89.into_context_iter();
                                                while let Some(v90) = v89.next(ctx) {
                                                    if let &InstructionData::IntCompare {
                                                        opcode: ref v1488,
                                                        args: ref v1489,
                                                        cond: ref v1490,
                                                    } = &v90.1 {
                                                        if let &Opcode::Icmp = v1488 {
                                                            match v1490 {
                                                                &IntCC::Equal => {
                                                                    if v2.0 == v90.0 {
                                                                        let mut v1496 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v79.2, &mut v1496);
                                                                        let mut v1496 = v1496.into_context_iter();
                                                                        while let Some(v1497) = v1496.next(ctx) {
                                                                            if let &InstructionData::UnaryImm {
                                                                                opcode: ref v1615,
                                                                                imm: v1616,
                                                                            } = &v1497.1 {
                                                                                if let &Opcode::Iconst = v1615 {
                                                                                    let v1617 = C::u64_from_imm64(ctx, v1616);
                                                                                    if v1617 == 0x1_u64 {
                                                                                        if v2.0 == v1497.0 {
                                                                                            let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                                            let v1491 = C::unpack_value_array_2(ctx, v1489);
                                                                                            if v1483.0 == v1491.0 {
                                                                                                if v1483.1 == v1491.1 {
                                                                                                    let v1753 = constructor_ule(ctx, v2.0, v1483.1, v1483.0);
                                                                                                    // Rule at src/opts/selects.isle line 158.
                                                                                                    returns.extend(Some(v1753));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                            if v1483.0 == v1491.1 {
                                                                                                if v1483.1 == v1491.0 {
                                                                                                    let v1753 = constructor_ule(ctx, v2.0, v1483.1, v1483.0);
                                                                                                    // Rule at src/opts/selects.isle line 154.
                                                                                                    returns.extend(Some(v1753));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &IntCC::UnsignedGreaterThan => {
                                                                    if v2.0 == v90.0 {
                                                                        let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                        let v1491 = C::unpack_value_array_2(ctx, v1489);
                                                                        if v1483.0 == v1491.1 {
                                                                            if v1483.1 == v1491.0 {
                                                                                let mut v1496 = C::inst_data_value_etor_returns::default();
                                                                                C::inst_data_value_etor(ctx, v79.2, &mut v1496);
                                                                                let mut v1496 = v1496.into_context_iter();
                                                                                while let Some(v1497) = v1496.next(ctx) {
                                                                                    if let &InstructionData::UnaryImm {
                                                                                        opcode: ref v1615,
                                                                                        imm: v1616,
                                                                                    } = &v1497.1 {
                                                                                        if let &Opcode::Iconst = v1615 {
                                                                                            let v1617 = C::u64_from_imm64(ctx, v1616);
                                                                                            if v1617 == 0x1_u64 {
                                                                                                if v2.0 == v1497.0 {
                                                                                                    let v1755 = constructor_ne(ctx, v2.0, v1483.1, v1483.0);
                                                                                                    // Rule at src/opts/selects.isle line 173.
                                                                                                    returns.extend(Some(v1755));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &IntCC::UnsignedLessThan => {
                                                                    if v2.0 == v90.0 {
                                                                        let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                        let v1491 = C::unpack_value_array_2(ctx, v1489);
                                                                        if v1483.0 == v1491.0 {
                                                                            if v1483.1 == v1491.1 {
                                                                                let mut v1496 = C::inst_data_value_etor_returns::default();
                                                                                C::inst_data_value_etor(ctx, v79.2, &mut v1496);
                                                                                let mut v1496 = v1496.into_context_iter();
                                                                                while let Some(v1497) = v1496.next(ctx) {
                                                                                    if let &InstructionData::UnaryImm {
                                                                                        opcode: ref v1615,
                                                                                        imm: v1616,
                                                                                    } = &v1497.1 {
                                                                                        if let &Opcode::Iconst = v1615 {
                                                                                            let v1617 = C::u64_from_imm64(ctx, v1616);
                                                                                            if v1617 == 0x1_u64 {
                                                                                                if v2.0 == v1497.0 {
                                                                                                    let v1755 = constructor_ne(ctx, v2.0, v1483.1, v1483.0);
                                                                                                    // Rule at src/opts/selects.isle line 177.
                                                                                                    returns.extend(Some(v1755));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                    }
                                                }
                                                let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                if v79.1 == v1483.0 {
                                                    if v79.2 == v1483.1 {
                                                        let v1640 = constructor_umin(ctx, v2.0, v1483.0, v1483.1);
                                                        // Rule at src/opts/selects.isle line 32.
                                                        returns.extend(Some(v1640));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v79.1 == v1483.1 {
                                                    if v79.2 == v1483.0 {
                                                        let v1638 = constructor_umax(ctx, v2.0, v1483.0, v1483.1);
                                                        // Rule at src/opts/selects.isle line 38.
                                                        returns.extend(Some(v1638));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                        let mut v89 = C::inst_data_value_etor_returns::default();
                                        C::inst_data_value_etor(ctx, v79.1, &mut v89);
                                        let mut v89 = v89.into_context_iter();
                                        while let Some(v90) = v89.next(ctx) {
                                            if let &InstructionData::UnaryImm {
                                                opcode: ref v1612,
                                                imm: v1613,
                                            } = &v90.1 {
                                                if let &Opcode::Iconst = v1612 {
                                                    let v1614 = C::u64_from_imm64(ctx, v1613);
                                                    match v1614 {
                                                        0x0_u64 => {
                                                            let mut v1496 = C::inst_data_value_etor_returns::default();
                                                            C::inst_data_value_etor(ctx, v79.2, &mut v1496);
                                                            let mut v1496 = v1496.into_context_iter();
                                                            while let Some(v1497) = v1496.next(ctx) {
                                                                if let &InstructionData::UnaryImm {
                                                                    opcode: ref v1615,
                                                                    imm: v1616,
                                                                } = &v1497.1 {
                                                                    if let &Opcode::Iconst = v1615 {
                                                                        let v1617 = C::u64_from_imm64(ctx, v1616);
                                                                        let v1618 = C::u64_matches_non_zero(ctx, v1617);
                                                                        if let Some(v1619) = v1618 {
                                                                            if v1619 == true {
                                                                                let v1620 = &C::intcc_complement(ctx, v1482);
                                                                                let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                                                let v1621 = constructor_icmp(ctx, v84.0, v1620, v1483.0, v1483.1);
                                                                                let v1622 = constructor_select(ctx, v2.0, v1621, v79.2, v79.1);
                                                                                // Rule at src/opts/selects.isle line 8.
                                                                                returns.extend(Some(v1622));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        0x1_u64 => {
                                                            let mut v1496 = C::inst_data_value_etor_returns::default();
                                                            C::inst_data_value_etor(ctx, v79.2, &mut v1496);
                                                            let mut v1496 = v1496.into_context_iter();
                                                            while let Some(v1497) = v1496.next(ctx) {
                                                                if let &InstructionData::UnaryImm {
                                                                    opcode: ref v1615,
                                                                    imm: v1616,
                                                                } = &v1497.1 {
                                                                    if let &Opcode::Iconst = v1615 {
                                                                        let v1617 = C::u64_from_imm64(ctx, v1616);
                                                                        if v1617 == 0x0_u64 {
                                                                            let v1623 = constructor_uextend_maybe(ctx, v2.0, v79.0);
                                                                            // Rule at src/opts/selects.isle line 14.
                                                                            returns.extend(Some(v1623));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                            }
                                        }
                                        let mut v1624 = C::inst_data_value_tupled_etor_returns::default();
                                        C::inst_data_value_tupled_etor(ctx, v79.1, &mut v1624);
                                        let mut v1624 = v1624.into_context_iter();
                                        while let Some(v1625) = v1624.next(ctx) {
                                            let v1626 = C::iconst_sextend_etor(ctx, v1625);
                                            if let Some(v1627) = v1626 {
                                                if v1627.1 == -1_i64 {
                                                    let mut v1630 = C::inst_data_value_tupled_etor_returns::default();
                                                    C::inst_data_value_tupled_etor(ctx, v79.2, &mut v1630);
                                                    let mut v1630 = v1630.into_context_iter();
                                                    while let Some(v1631) = v1630.next(ctx) {
                                                        let v1632 = C::iconst_sextend_etor(ctx, v1631);
                                                        if let Some(v1633) = v1632 {
                                                            if v1633.1 == 0_i64 {
                                                                let v1636 = constructor_bmask(ctx, v2.0, v79.0);
                                                                // Rule at src/opts/selects.isle line 19.
                                                                returns.extend(Some(v1636));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v87,
                                    arg: v88,
                                } => {
                                    if let &Opcode::Uextend = v87 {
                                        let mut v1433 = C::inst_data_value_etor_returns::default();
                                        C::inst_data_value_etor(ctx, v88, &mut v1433);
                                        let mut v1433 = v1433.into_context_iter();
                                        while let Some(v1434) = v1433.next(ctx) {
                                            if let &InstructionData::IntCompare {
                                                opcode: ref v1437,
                                                args: ref v1438,
                                                cond: ref v1439,
                                            } = &v1434.1 {
                                                if let &Opcode::Icmp = v1437 {
                                                    let v1443 = constructor_select(ctx, v2.0, v88, v79.1, v79.2);
                                                    // Rule at src/opts/icmp.isle line 83.
                                                    returns.extend(Some(v1443));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v1057,
                                    imm: v1058,
                                } => {
                                    if let &Opcode::Iconst = v1057 {
                                        let v1059 = C::u64_from_imm64(ctx, v1058);
                                        if v1059 == 0x0_u64 {
                                            let v1063 = C::subsume(ctx, v79.2);
                                            // Rule at src/opts/cprop.isle line 228.
                                            returns.extend(Some(v1063));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        let v1060 = C::u64_matches_non_zero(ctx, v1059);
                                        if let Some(v1061) = v1060 {
                                            if v1061 == true {
                                                let v1062 = C::subsume(ctx, v79.1);
                                                // Rule at src/opts/cprop.isle line 226.
                                                returns.extend(Some(v1062));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                        let mut v89 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v79.1, &mut v89);
                        let mut v89 = v89.into_context_iter();
                        while let Some(v90) = v89.next(ctx) {
                            match &v90.1 {
                                &InstructionData::IntCompare {
                                    opcode: ref v1488,
                                    args: ref v1489,
                                    cond: ref v1490,
                                } => {
                                    if let &Opcode::Icmp = v1488 {
                                        if let &IntCC::Equal = v1490 {
                                            if v2.0 == v90.0 {
                                                let mut v1496 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v79.2, &mut v1496);
                                                let mut v1496 = v1496.into_context_iter();
                                                while let Some(v1497) = v1496.next(ctx) {
                                                    if let &InstructionData::IntCompare {
                                                        opcode: ref v1500,
                                                        args: ref v1501,
                                                        cond: ref v1502,
                                                    } = &v1497.1 {
                                                        if let &Opcode::Icmp = v1500 {
                                                            if let &IntCC::Equal = v1502 {
                                                                if v2.0 == v1497.0 {
                                                                    let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                    let mut v1781 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v1503.0, &mut v1781);
                                                                    let mut v1781 = v1781.into_context_iter();
                                                                    while let Some(v1782) = v1781.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v1785,
                                                                            imm: v1786,
                                                                        } = &v1782.1 {
                                                                            if let &Opcode::Iconst = v1785 {
                                                                                let v1491 = C::unpack_value_array_2(ctx, v1489);
                                                                                if v1491.0 == v1503.1 {
                                                                                    let v1787 = C::u64_from_imm64(ctx, v1786);
                                                                                    let v1788 = constructor_iconst_u(ctx, v1782.0, v1787);
                                                                                    let v1801 = constructor_select(ctx, v1782.0, v79.0, v1491.1, v1788);
                                                                                    let v1802 = constructor_eq(ctx, v2.0, v1491.0, v1801);
                                                                                    // Rule at src/opts/selects.isle line 193.
                                                                                    returns.extend(Some(v1802));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                                if v1491.1 == v1503.1 {
                                                                                    let v1787 = C::u64_from_imm64(ctx, v1786);
                                                                                    let v1788 = constructor_iconst_u(ctx, v1782.0, v1787);
                                                                                    let v1789 = constructor_select(ctx, v1782.0, v79.0, v1491.0, v1788);
                                                                                    let v1790 = constructor_eq(ctx, v2.0, v1491.1, v1789);
                                                                                    // Rule at src/opts/selects.isle line 191.
                                                                                    returns.extend(Some(v1790));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    let mut v1791 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v1503.1, &mut v1791);
                                                                    let mut v1791 = v1791.into_context_iter();
                                                                    while let Some(v1792) = v1791.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v1795,
                                                                            imm: v1796,
                                                                        } = &v1792.1 {
                                                                            if let &Opcode::Iconst = v1795 {
                                                                                let v1491 = C::unpack_value_array_2(ctx, v1489);
                                                                                if v1491.0 == v1503.0 {
                                                                                    let v1797 = C::u64_from_imm64(ctx, v1796);
                                                                                    let v1798 = constructor_iconst_u(ctx, v1792.0, v1797);
                                                                                    let v1803 = constructor_select(ctx, v1792.0, v79.0, v1491.1, v1798);
                                                                                    let v1804 = constructor_eq(ctx, v2.0, v1491.0, v1803);
                                                                                    // Rule at src/opts/selects.isle line 194.
                                                                                    returns.extend(Some(v1804));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                                if v1491.1 == v1503.0 {
                                                                                    let v1797 = C::u64_from_imm64(ctx, v1796);
                                                                                    let v1798 = constructor_iconst_u(ctx, v1792.0, v1797);
                                                                                    let v1799 = constructor_select(ctx, v1792.0, v79.0, v1491.0, v1798);
                                                                                    let v1800 = constructor_eq(ctx, v2.0, v1491.1, v1799);
                                                                                    // Rule at src/opts/selects.isle line 192.
                                                                                    returns.extend(Some(v1800));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::Ternary {
                                    opcode: ref v1699,
                                    args: ref v1700,
                                } => {
                                    if let &Opcode::Select = v1699 {
                                        if v2.0 == v90.0 {
                                            let v1701 = C::unpack_value_array_3(ctx, v1700);
                                            if v79.0 == v1701.0 {
                                                let v1705 = constructor_select(ctx, v2.0, v79.0, v1701.1, v79.2);
                                                // Rule at src/opts/selects.isle line 102.
                                                returns.extend(Some(v1705));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v93,
                                    arg: v94,
                                } => {
                                    match v93 {
                                        &Opcode::Uextend => {
                                            if v2.0 == v90.0 {
                                                let mut v1496 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v79.2, &mut v1496);
                                                let mut v1496 = v1496.into_context_iter();
                                                while let Some(v1497) = v1496.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v1654,
                                                        arg: v1655,
                                                    } = &v1497.1 {
                                                        if let &Opcode::Uextend = v1654 {
                                                            if v2.0 == v1497.0 {
                                                                let v1653 = C::value_type(ctx, v94);
                                                                let v1656 = C::value_type(ctx, v1655);
                                                                if v1653 == v1656 {
                                                                    let v1657 = constructor_select(ctx, v1653, v79.0, v94, v1655);
                                                                    let v1658 = constructor_uextend(ctx, v2.0, v1657);
                                                                    // Rule at src/opts/selects.isle line 80.
                                                                    returns.extend(Some(v1658));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Sextend => {
                                            if v2.0 == v90.0 {
                                                let mut v1496 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v79.2, &mut v1496);
                                                let mut v1496 = v1496.into_context_iter();
                                                while let Some(v1497) = v1496.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v1654,
                                                        arg: v1655,
                                                    } = &v1497.1 {
                                                        if let &Opcode::Sextend = v1654 {
                                                            if v2.0 == v1497.0 {
                                                                let v1653 = C::value_type(ctx, v94);
                                                                let v1656 = C::value_type(ctx, v1655);
                                                                if v1653 == v1656 {
                                                                    let v1657 = constructor_select(ctx, v1653, v79.0, v94, v1655);
                                                                    let v1659 = constructor_sextend(ctx, v2.0, v1657);
                                                                    // Rule at src/opts/selects.isle line 84.
                                                                    returns.extend(Some(v1659));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v1612,
                                    imm: v1613,
                                } => {
                                    if let &Opcode::Iconst = v1612 {
                                        let v1614 = C::u64_from_imm64(ctx, v1613);
                                        if v1614 == 0x1_u64 {
                                            if v2.0 == v90.0 {
                                                let mut v1496 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v79.2, &mut v1496);
                                                let mut v1496 = v1496.into_context_iter();
                                                while let Some(v1497) = v1496.next(ctx) {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v1738,
                                                        args: ref v1739,
                                                    } = &v1497.1 {
                                                        if let &Opcode::Bor = v1738 {
                                                            if v2.0 == v1497.0 {
                                                                let v1740 = C::unpack_value_array_2(ctx, v1739);
                                                                if v79.0 == v1740.0 {
                                                                    let v1350 = constructor_iconst_u(ctx, v2.0, 0x1_u64);
                                                                    let v1756 = constructor_select(ctx, v2.0, v79.0, v1350, v1740.1);
                                                                    // Rule at src/opts/selects.isle line 180.
                                                                    returns.extend(Some(v1756));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v79.0 == v1740.1 {
                                                                    let v1350 = constructor_iconst_u(ctx, v2.0, 0x1_u64);
                                                                    let v1757 = constructor_select(ctx, v2.0, v79.0, v1350, v1740.0);
                                                                    // Rule at src/opts/selects.isle line 181.
                                                                    returns.extend(Some(v1757));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                        if v79.1 == v79.2 {
                            let v1062 = C::subsume(ctx, v79.1);
                            // Rule at src/opts/selects.isle line 3.
                            returns.extend(Some(v1062));
                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                        }
                        let mut v373 = ContextIterWrapper::<ConstructorVec<_>, _>::default();
                        constructor_truthy(ctx, v79.0, &mut v373);
                        let mut v373 = v373.into_context_iter();
                        while let Some(v374) = v373.next(ctx) {
                            let v375 = constructor_select(ctx, v2.0, v374, v79.1, v79.2);
                            // Rule at src/opts/bitops.isle line 112.
                            returns.extend(Some(v375));
                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                        }
                        let mut v1496 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v79.2, &mut v1496);
                        let mut v1496 = v1496.into_context_iter();
                        while let Some(v1497) = v1496.next(ctx) {
                            if let &InstructionData::Ternary {
                                opcode: ref v1692,
                                args: ref v1693,
                            } = &v1497.1 {
                                if let &Opcode::Select = v1692 {
                                    if v2.0 == v1497.0 {
                                        let v1694 = C::unpack_value_array_3(ctx, v1693);
                                        if v79.0 == v1694.0 {
                                            let v1698 = constructor_select(ctx, v2.0, v79.0, v79.1, v1694.2);
                                            // Rule at src/opts/selects.isle line 101.
                                            returns.extend(Some(v1698));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    &Opcode::SelectSpectreGuard => {
                        let v79 = C::unpack_value_array_3(ctx, v78);
                        let mut v83 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v79.0, &mut v83);
                        let mut v83 = v83.into_context_iter();
                        while let Some(v84) = v83.next(ctx) {
                            if let &InstructionData::UnaryImm {
                                opcode: ref v1057,
                                imm: v1058,
                            } = &v84.1 {
                                if let &Opcode::Iconst = v1057 {
                                    let v1059 = C::u64_from_imm64(ctx, v1058);
                                    if v1059 == 0x0_u64 {
                                        let v1063 = C::subsume(ctx, v79.2);
                                        // Rule at src/opts/spectre.isle line 13.
                                        returns.extend(Some(v1063));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                    let v1060 = C::u64_matches_non_zero(ctx, v1059);
                                    if let Some(v1061) = v1060 {
                                        if v1061 == true {
                                            let v1062 = C::subsume(ctx, v79.1);
                                            // Rule at src/opts/spectre.isle line 11.
                                            returns.extend(Some(v1062));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                            }
                        }
                        if v79.1 == v79.2 {
                            let v1062 = C::subsume(ctx, v79.1);
                            // Rule at src/opts/spectre.isle line 9.
                            returns.extend(Some(v1062));
                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                        }
                    }
                    &Opcode::Bitselect => {
                        let v1641 = C::multi_lane(ctx, v2.0);
                        if let Some(v1642) = v1641 {
                            let v79 = C::unpack_value_array_3(ctx, v78);
                            let mut v83 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v79.0, &mut v83);
                            let mut v83 = v83.into_context_iter();
                            while let Some(v84) = v83.next(ctx) {
                                if let &InstructionData::IntCompare {
                                    opcode: ref v1480,
                                    args: ref v1481,
                                    cond: ref v1482,
                                } = &v84.1 {
                                    if let &Opcode::Icmp = v1480 {
                                        match v1482 {
                                            &IntCC::SignedGreaterThan => {
                                                let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                if v79.1 == v1483.0 {
                                                    if v79.2 == v1483.1 {
                                                        let v1637 = constructor_smax(ctx, v2.0, v1483.0, v1483.1);
                                                        // Rule at src/opts/selects.isle line 45.
                                                        returns.extend(Some(v1637));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v79.1 == v1483.1 {
                                                    if v79.2 == v1483.0 {
                                                        let v1639 = constructor_smin(ctx, v2.0, v1483.0, v1483.1);
                                                        // Rule at src/opts/selects.isle line 59.
                                                        returns.extend(Some(v1639));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::SignedGreaterThanOrEqual => {
                                                let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                if v79.1 == v1483.0 {
                                                    if v79.2 == v1483.1 {
                                                        let v1637 = constructor_smax(ctx, v2.0, v1483.0, v1483.1);
                                                        // Rule at src/opts/selects.isle line 46.
                                                        returns.extend(Some(v1637));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v79.1 == v1483.1 {
                                                    if v79.2 == v1483.0 {
                                                        let v1639 = constructor_smin(ctx, v2.0, v1483.0, v1483.1);
                                                        // Rule at src/opts/selects.isle line 60.
                                                        returns.extend(Some(v1639));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::SignedLessThan => {
                                                let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                if v79.1 == v1483.0 {
                                                    if v79.2 == v1483.1 {
                                                        let v1639 = constructor_smin(ctx, v2.0, v1483.0, v1483.1);
                                                        // Rule at src/opts/selects.isle line 49.
                                                        returns.extend(Some(v1639));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v79.1 == v1483.1 {
                                                    if v79.2 == v1483.0 {
                                                        let v1637 = constructor_smax(ctx, v2.0, v1483.0, v1483.1);
                                                        // Rule at src/opts/selects.isle line 55.
                                                        returns.extend(Some(v1637));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::SignedLessThanOrEqual => {
                                                let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                if v79.1 == v1483.0 {
                                                    if v79.2 == v1483.1 {
                                                        let v1639 = constructor_smin(ctx, v2.0, v1483.0, v1483.1);
                                                        // Rule at src/opts/selects.isle line 50.
                                                        returns.extend(Some(v1639));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v79.1 == v1483.1 {
                                                    if v79.2 == v1483.0 {
                                                        let v1637 = constructor_smax(ctx, v2.0, v1483.0, v1483.1);
                                                        // Rule at src/opts/selects.isle line 56.
                                                        returns.extend(Some(v1637));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::UnsignedGreaterThan => {
                                                let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                if v79.1 == v1483.0 {
                                                    if v79.2 == v1483.1 {
                                                        let v1638 = constructor_umax(ctx, v2.0, v1483.0, v1483.1);
                                                        // Rule at src/opts/selects.isle line 47.
                                                        returns.extend(Some(v1638));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v79.1 == v1483.1 {
                                                    if v79.2 == v1483.0 {
                                                        let v1640 = constructor_umin(ctx, v2.0, v1483.0, v1483.1);
                                                        // Rule at src/opts/selects.isle line 61.
                                                        returns.extend(Some(v1640));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::UnsignedGreaterThanOrEqual => {
                                                let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                if v79.1 == v1483.0 {
                                                    if v79.2 == v1483.1 {
                                                        let v1638 = constructor_umax(ctx, v2.0, v1483.0, v1483.1);
                                                        // Rule at src/opts/selects.isle line 48.
                                                        returns.extend(Some(v1638));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v79.1 == v1483.1 {
                                                    if v79.2 == v1483.0 {
                                                        let v1640 = constructor_umin(ctx, v2.0, v1483.0, v1483.1);
                                                        // Rule at src/opts/selects.isle line 62.
                                                        returns.extend(Some(v1640));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::UnsignedLessThan => {
                                                let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                if v79.1 == v1483.0 {
                                                    if v79.2 == v1483.1 {
                                                        let v1640 = constructor_umin(ctx, v2.0, v1483.0, v1483.1);
                                                        // Rule at src/opts/selects.isle line 51.
                                                        returns.extend(Some(v1640));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v79.1 == v1483.1 {
                                                    if v79.2 == v1483.0 {
                                                        let v1638 = constructor_umax(ctx, v2.0, v1483.0, v1483.1);
                                                        // Rule at src/opts/selects.isle line 57.
                                                        returns.extend(Some(v1638));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::UnsignedLessThanOrEqual => {
                                                let v1483 = C::unpack_value_array_2(ctx, v1481);
                                                if v79.1 == v1483.0 {
                                                    if v79.2 == v1483.1 {
                                                        let v1640 = constructor_umin(ctx, v2.0, v1483.0, v1483.1);
                                                        // Rule at src/opts/selects.isle line 52.
                                                        returns.extend(Some(v1640));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v79.1 == v1483.1 {
                                                    if v79.2 == v1483.0 {
                                                        let v1638 = constructor_umax(ctx, v2.0, v1483.0, v1483.1);
                                                        // Rule at src/opts/selects.isle line 58.
                                                        returns.extend(Some(v1638));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                }
                            }
                        }
                        let v79 = C::unpack_value_array_3(ctx, v78);
                        if v79.1 == v79.2 {
                            let v1062 = C::subsume(ctx, v79.1);
                            // Rule at src/opts/selects.isle line 4.
                            returns.extend(Some(v1062));
                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                        }
                    }
                    &Opcode::Fma => {
                        let v79 = C::unpack_value_array_3(ctx, v78);
                        let mut v83 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v79.0, &mut v83);
                        let mut v83 = v83.into_context_iter();
                        while let Some(v84) = v83.next(ctx) {
                            if let &InstructionData::Unary {
                                opcode: ref v87,
                                arg: v88,
                            } = &v84.1 {
                                if let &Opcode::Fneg = v87 {
                                    if v2.0 == v84.0 {
                                        let mut v89 = C::inst_data_value_etor_returns::default();
                                        C::inst_data_value_etor(ctx, v79.1, &mut v89);
                                        let mut v89 = v89.into_context_iter();
                                        while let Some(v90) = v89.next(ctx) {
                                            if let &InstructionData::Unary {
                                                opcode: ref v93,
                                                arg: v94,
                                            } = &v90.1 {
                                                if let &Opcode::Fneg = v93 {
                                                    if v2.0 == v90.0 {
                                                        let v95 = constructor_fma(ctx, v2.0, v88, v94, v79.2);
                                                        // Rule at src/opts/arithmetic.isle line 188.
                                                        returns.extend(Some(v95));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    _ => {}
                }
            }
            &InstructionData::Unary {
                opcode: ref v32,
                arg: v33,
            } => {
                match v32 {
                    &Opcode::Splat => {
                        let v1090 = C::ty_vec128(ctx, v2.0);
                        if let Some(v1091) = v1090 {
                            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 v1107,
                                        imm: v1108,
                                    } => {
                                        if let &Opcode::F32const = v1107 {
                                            let v1109 = C::u32_from_ieee32(ctx, v1108);
                                            let v1110 = C::u32_into_u64(ctx, v1109);
                                            let v1111 = constructor_splat32(ctx, v1110);
                                            let v1112 = constructor_vconst(ctx, v1091, v1111);
                                            // Rule at src/opts/cprop.isle line 283.
                                            returns.extend(Some(v1112));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                    &InstructionData::UnaryIeee64 {
                                        opcode: ref v1113,
                                        imm: v1114,
                                    } => {
                                        if let &Opcode::F64const = v1113 {
                                            let v1115 = C::u64_from_ieee64(ctx, v1114);
                                            let v1116 = C::splat64(ctx, v1115);
                                            let v1117 = constructor_vconst(ctx, v1091, v1116);
                                            // Rule at src/opts/cprop.isle line 285.
                                            returns.extend(Some(v1117));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                    &InstructionData::UnaryImm {
                                        opcode: ref v944,
                                        imm: v945,
                                    } => {
                                        if let &Opcode::Iconst = v944 {
                                            match v35.0 {
                                                I8 => {
                                                    let v1092 = C::u64_uextend_imm64(ctx, I8, v945);
                                                    let v1093 = constructor_splat8(ctx, v1092);
                                                    let v1094 = constructor_vconst(ctx, v1091, v1093);
                                                    // Rule at src/opts/cprop.isle line 275.
                                                    returns.extend(Some(v1094));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                I16 => {
                                                    let v1096 = C::u64_uextend_imm64(ctx, I16, v945);
                                                    let v1097 = constructor_splat16(ctx, v1096);
                                                    let v1098 = constructor_vconst(ctx, v1091, v1097);
                                                    // Rule at src/opts/cprop.isle line 277.
                                                    returns.extend(Some(v1098));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                I32 => {
                                                    let v1100 = C::u64_uextend_imm64(ctx, I32, v945);
                                                    let v1101 = constructor_splat32(ctx, v1100);
                                                    let v1102 = constructor_vconst(ctx, v1091, v1101);
                                                    // Rule at src/opts/cprop.isle line 279.
                                                    returns.extend(Some(v1102));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                I64 => {
                                                    let v1104 = C::u64_uextend_imm64(ctx, I64, v945);
                                                    let v1105 = C::splat64(ctx, v1104);
                                                    let v1106 = constructor_vconst(ctx, v1091, v1105);
                                                    // Rule at src/opts/cprop.isle line 281.
                                                    returns.extend(Some(v1106));
                                                    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 v304 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v40.0, &mut v304);
                                                let mut v304 = v304.into_context_iter();
                                                while let Some(v305) = v304.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v308,
                                                        arg: v309,
                                                    } = &v305.1 {
                                                        if let &Opcode::Ineg = v308 {
                                                            if v2.0 == v305.0 {
                                                                let v310 = constructor_imul(ctx, v2.0, v40.1, v309);
                                                                // Rule at src/opts/arithmetic.isle line 409.
                                                                returns.extend(Some(v310));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                                let mut v311 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v40.1, &mut v311);
                                                let mut v311 = v311.into_context_iter();
                                                while let Some(v312) = v311.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v315,
                                                        arg: v316,
                                                    } = &v312.1 {
                                                        if let &Opcode::Ineg = v315 {
                                                            if v2.0 == v312.0 {
                                                                let v317 = constructor_imul(ctx, v2.0, v40.0, v316);
                                                                // Rule at src/opts/arithmetic.isle line 410.
                                                                returns.extend(Some(v317));
                                                                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 v311 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v40.1, &mut v311);
                                                let mut v311 = v311.into_context_iter();
                                                while let Some(v312) = v311.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v1333,
                                                        imm: v1334,
                                                    } = &v312.1 {
                                                        if let &Opcode::Iconst = v1333 {
                                                            let v1831 = C::u64_from_imm64(ctx, v1334);
                                                            let v358 = constructor_ty_shift_mask(ctx, v2.0);
                                                            let v1832 = C::u64_eq(ctx, v1831, v358);
                                                            if v1832 == true {
                                                                if v2.0 == v312.0 {
                                                                    let v1833 = constructor_sshr(ctx, v2.0, v40.0, v40.1);
                                                                    // Rule at src/opts/shifts.isle line 98.
                                                                    returns.extend(Some(v1833));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v45,
                                    arg: v46,
                                } => {
                                    match v45 {
                                        &Opcode::Splat => {
                                            if v2.0 == v35.0 {
                                                let v1849 = C::lane_type(ctx, v2.0);
                                                let v2005 = constructor_ineg(ctx, v1849, v46);
                                                let v2006 = constructor_splat(ctx, v2.0, v2005);
                                                // Rule at src/opts/vector.isle line 45.
                                                returns.extend(Some(v2006));
                                                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 v1849 = C::lane_type(ctx, v2.0);
                                            let v2007 = constructor_iabs(ctx, v1849, v46);
                                            let v2008 = constructor_splat(ctx, v2.0, v2007);
                                            // Rule at src/opts/vector.isle line 48.
                                            returns.extend(Some(v2008));
                                            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 v304 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v40.0, &mut v304);
                                                let mut v304 = v304.into_context_iter();
                                                while let Some(v305) = v304.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v308,
                                                        arg: v309,
                                                    } = &v305.1 {
                                                        if let &Opcode::Bnot = v308 {
                                                            if v2.0 == v305.0 {
                                                                let v786 = constructor_isub(ctx, v2.0, v309, v40.1);
                                                                // Rule at src/opts/bitops.isle line 410.
                                                                returns.extend(Some(v786));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                                let mut v311 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v40.1, &mut v311);
                                                let mut v311 = v311.into_context_iter();
                                                while let Some(v312) = v311.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v315,
                                                        arg: v316,
                                                    } = &v312.1 {
                                                        if let &Opcode::Bnot = v315 {
                                                            if v2.0 == v312.0 {
                                                                let v787 = constructor_isub(ctx, v2.0, v316, v40.0);
                                                                // Rule at src/opts/bitops.isle line 411.
                                                                returns.extend(Some(v787));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            let v334 = C::fits_in_64(ctx, v2.0);
                                            if let Some(v335) = v334 {
                                                if v35.0 == v335 {
                                                    let v40 = C::unpack_value_array_2(ctx, v39);
                                                    let mut v311 = C::inst_data_value_etor_returns::default();
                                                    C::inst_data_value_etor(ctx, v40.1, &mut v311);
                                                    let mut v311 = v311.into_context_iter();
                                                    while let Some(v312) = v311.next(ctx) {
                                                        if let &InstructionData::UnaryImm {
                                                            opcode: ref v1333,
                                                            imm: v1334,
                                                        } = &v312.1 {
                                                            if let &Opcode::Iconst = v1333 {
                                                                if v35.0 == v312.0 {
                                                                    let v1335 = constructor_bnot(ctx, v335, v40.0);
                                                                    let v1336 = C::imm64_neg(ctx, v335, v1334);
                                                                    let v1337 = constructor_iconst(ctx, v335, v1336);
                                                                    let v1338 = constructor_iadd(ctx, v335, v1335, v1337);
                                                                    // Rule at src/opts/cprop.isle line 501.
                                                                    returns.extend(Some(v1338));
                                                                    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 v304 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v40.0, &mut v304);
                                                let mut v304 = v304.into_context_iter();
                                                while let Some(v305) = v304.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v308,
                                                        arg: v309,
                                                    } = &v305.1 {
                                                        if let &Opcode::Bnot = v308 {
                                                            if v2.0 == v305.0 {
                                                                let v763 = constructor_bnot(ctx, v2.0, v40.1);
                                                                let v764 = constructor_bor(ctx, v2.0, v309, v763);
                                                                // Rule at src/opts/bitops.isle line 351.
                                                                returns.extend(Some(v764));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                                let mut v311 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v40.1, &mut v311);
                                                let mut v311 = v311.into_context_iter();
                                                while let Some(v312) = v311.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v315,
                                                        arg: v316,
                                                    } = &v312.1 {
                                                        if let &Opcode::Bnot = v315 {
                                                            if v2.0 == v312.0 {
                                                                let v765 = constructor_bnot(ctx, v2.0, v40.0);
                                                                let v766 = constructor_bor(ctx, v2.0, v316, v765);
                                                                // Rule at src/opts/bitops.isle line 352.
                                                                returns.extend(Some(v766));
                                                                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 v304 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v40.0, &mut v304);
                                                let mut v304 = v304.into_context_iter();
                                                while let Some(v305) = v304.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v308,
                                                        arg: v309,
                                                    } = &v305.1 {
                                                        if let &Opcode::Bnot = v308 {
                                                            if v2.0 == v305.0 {
                                                                let v763 = constructor_bnot(ctx, v2.0, v40.1);
                                                                let v767 = constructor_band(ctx, v2.0, v309, v763);
                                                                // Rule at src/opts/bitops.isle line 355.
                                                                returns.extend(Some(v767));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                                let mut v311 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v40.1, &mut v311);
                                                let mut v311 = v311.into_context_iter();
                                                while let Some(v312) = v311.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v315,
                                                        arg: v316,
                                                    } = &v312.1 {
                                                        if let &Opcode::Bnot = v315 {
                                                            if v2.0 == v312.0 {
                                                                let v765 = constructor_bnot(ctx, v2.0, v40.0);
                                                                let v768 = constructor_band(ctx, v2.0, v316, v765);
                                                                // Rule at src/opts/bitops.isle line 356.
                                                                returns.extend(Some(v768));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v45,
                                    arg: v46,
                                } => {
                                    match v45 {
                                        &Opcode::Splat => {
                                            let v1985 = C::ty_vector_not_float(ctx, v2.0);
                                            if let Some(v1986) = v1985 {
                                                if v2.0 == v35.0 {
                                                    let v1849 = C::lane_type(ctx, v2.0);
                                                    let v1993 = constructor_bnot(ctx, v1849, v46);
                                                    let v1994 = constructor_splat(ctx, v2.0, v1993);
                                                    // Rule at src/opts/vector.isle line 26.
                                                    returns.extend(Some(v1994));
                                                    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 v944,
                                    imm: v945,
                                } => {
                                    if let &Opcode::Iconst = v944 {
                                        let v334 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v335) = v334 {
                                            if v35.0 == v335 {
                                                let v970 = C::imm64_not(ctx, v335, v945);
                                                let v971 = constructor_iconst(ctx, v335, v970);
                                                let v972 = C::subsume(ctx, v971);
                                                // Rule at src/opts/cprop.isle line 73.
                                                returns.extend(Some(v972));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                        let v1605 = C::remat(ctx, arg0);
                        // Rule at src/opts/remat.isle line 23.
                        returns.extend(Some(v1605));
                        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 v334 = C::fits_in_64(ctx, v2.0);
                        if let Some(v335) = v334 {
                            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 v944,
                                    imm: v945,
                                } = &v35.1 {
                                    if let &Opcode::Iconst = v944 {
                                        if v35.0 == v335 {
                                            let v946 = C::imm64_clz(ctx, v335, v945);
                                            let v947 = constructor_iconst(ctx, v335, v946);
                                            let v948 = C::subsume(ctx, v947);
                                            // Rule at src/opts/cprop.isle line 2.
                                            returns.extend(Some(v948));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    &Opcode::Ctz => {
                        let v334 = C::fits_in_64(ctx, v2.0);
                        if let Some(v335) = v334 {
                            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 v944,
                                    imm: v945,
                                } = &v35.1 {
                                    if let &Opcode::Iconst = v944 {
                                        if v35.0 == v335 {
                                            let v949 = C::imm64_ctz(ctx, v335, v945);
                                            let v950 = constructor_iconst(ctx, v335, v949);
                                            let v951 = C::subsume(ctx, v950);
                                            // Rule at src/opts/cprop.isle line 8.
                                            returns.extend(Some(v951));
                                            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 v944,
                                    imm: v945,
                                } => {
                                    if let &Opcode::Iconst = v944 {
                                        match v2.0 {
                                            I16 => {
                                                let v1002 = C::u64_from_imm64(ctx, v945);
                                                let v1148 = C::u64_bswap16(ctx, v1002);
                                                let v1149 = C::imm64(ctx, v1148);
                                                let v1150 = constructor_iconst(ctx, I16, v1149);
                                                let v1151 = C::subsume(ctx, v1150);
                                                // Rule at src/opts/cprop.isle line 355.
                                                returns.extend(Some(v1151));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            I32 => {
                                                let v1002 = C::u64_from_imm64(ctx, v945);
                                                let v1152 = C::u64_bswap32(ctx, v1002);
                                                let v1153 = C::imm64(ctx, v1152);
                                                let v1154 = constructor_iconst(ctx, I32, v1153);
                                                let v1155 = C::subsume(ctx, v1154);
                                                // Rule at src/opts/cprop.isle line 357.
                                                returns.extend(Some(v1155));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            I64 => {
                                                let v1002 = C::u64_from_imm64(ctx, v945);
                                                let v1156 = C::u64_bswap64(ctx, v1002);
                                                let v1157 = C::imm64(ctx, v1156);
                                                let v1158 = constructor_iconst(ctx, I64, v1157);
                                                let v1159 = C::subsume(ctx, v1158);
                                                // Rule at src/opts/cprop.isle line 359.
                                                returns.extend(Some(v1159));
                                                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 v1849 = C::lane_type(ctx, v2.0);
                                        let v2009 = constructor_popcnt(ctx, v1849, v46);
                                        let v2010 = constructor_splat(ctx, v2.0, v2009);
                                        // Rule at src/opts/vector.isle line 51.
                                        returns.extend(Some(v2010));
                                        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 v1107,
                                            imm: v1108,
                                        } = &v35.1 {
                                            if let &Opcode::F32const = v1107 {
                                                let v1200 = C::f32_sqrt(ctx, v1108);
                                                if let Some(v1201) = v1200 {
                                                    let v1202 = constructor_f32const(ctx, F32, v1201);
                                                    let v1203 = C::subsume(ctx, v1202);
                                                    // Rule at src/opts/cprop.isle line 406.
                                                    returns.extend(Some(v1203));
                                                    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 v1113,
                                            imm: v1114,
                                        } = &v35.1 {
                                            if let &Opcode::F64const = v1113 {
                                                let v1204 = C::f64_sqrt(ctx, v1114);
                                                if let Some(v1205) = v1204 {
                                                    let v1206 = constructor_f64const(ctx, F64, v1205);
                                                    let v1207 = C::subsume(ctx, v1206);
                                                    // Rule at src/opts/cprop.isle line 409.
                                                    returns.extend(Some(v1207));
                                                    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 184.
                                            returns.extend(Some(v47));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                                &InstructionData::UnaryConst {
                                    opcode: ref v1299,
                                    constant_handle: v1300,
                                } => {
                                    if let &Opcode::F128const = v1299 {
                                        if v2.0 == F128 {
                                            if v35.0 == F128 {
                                                let v1301 = C::ieee128_constant_extractor(ctx, v1300);
                                                if let Some(v1302) = v1301 {
                                                    let v1303 = C::f128_neg(ctx, v1302);
                                                    let v1304 = C::ieee128_constant(ctx, v1303);
                                                    let v1305 = constructor_f128const(ctx, F128, v1304);
                                                    let v1306 = C::subsume(ctx, v1305);
                                                    // Rule at src/opts/cprop.isle line 473.
                                                    returns.extend(Some(v1306));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryIeee16 {
                                    opcode: ref v1288,
                                    imm: v1289,
                                } => {
                                    if let &Opcode::F16const = v1288 {
                                        if v2.0 == F16 {
                                            if v35.0 == F16 {
                                                let v1290 = C::f16_neg(ctx, v1289);
                                                let v1291 = constructor_f16const(ctx, F16, v1290);
                                                let v1292 = C::subsume(ctx, v1291);
                                                // Rule at src/opts/cprop.isle line 467.
                                                returns.extend(Some(v1292));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryIeee32 {
                                    opcode: ref v1107,
                                    imm: v1108,
                                } => {
                                    if let &Opcode::F32const = v1107 {
                                        if v2.0 == F32 {
                                            if v35.0 == F32 {
                                                let v1293 = C::f32_neg(ctx, v1108);
                                                let v1294 = constructor_f32const(ctx, F32, v1293);
                                                let v1295 = C::subsume(ctx, v1294);
                                                // Rule at src/opts/cprop.isle line 469.
                                                returns.extend(Some(v1295));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryIeee64 {
                                    opcode: ref v1113,
                                    imm: v1114,
                                } => {
                                    if let &Opcode::F64const = v1113 {
                                        if v2.0 == F64 {
                                            if v35.0 == F64 {
                                                let v1296 = C::f64_neg(ctx, v1114);
                                                let v1297 = constructor_f64const(ctx, F64, v1296);
                                                let v1298 = C::subsume(ctx, v1297);
                                                // Rule at src/opts/cprop.isle line 471.
                                                returns.extend(Some(v1298));
                                                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 v1288,
                                            imm: v1289,
                                        } = &v35.1 {
                                            if let &Opcode::F16const = v1288 {
                                                let v1307 = C::f16_abs(ctx, v1289);
                                                let v1308 = constructor_f16const(ctx, F16, v1307);
                                                let v1309 = C::subsume(ctx, v1308);
                                                // Rule at src/opts/cprop.isle line 476.
                                                returns.extend(Some(v1309));
                                                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 v1107,
                                            imm: v1108,
                                        } = &v35.1 {
                                            if let &Opcode::F32const = v1107 {
                                                let v1310 = C::f32_abs(ctx, v1108);
                                                let v1311 = constructor_f32const(ctx, F32, v1310);
                                                let v1312 = C::subsume(ctx, v1311);
                                                // Rule at src/opts/cprop.isle line 478.
                                                returns.extend(Some(v1312));
                                                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 v1113,
                                            imm: v1114,
                                        } = &v35.1 {
                                            if let &Opcode::F64const = v1113 {
                                                let v1313 = C::f64_abs(ctx, v1114);
                                                let v1314 = constructor_f64const(ctx, F64, v1313);
                                                let v1315 = C::subsume(ctx, v1314);
                                                // Rule at src/opts/cprop.isle line 480.
                                                returns.extend(Some(v1315));
                                                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 v1299,
                                            constant_handle: v1300,
                                        } = &v35.1 {
                                            if let &Opcode::F128const = v1299 {
                                                let v1301 = C::ieee128_constant_extractor(ctx, v1300);
                                                if let Some(v1302) = v1301 {
                                                    let v1316 = C::f128_abs(ctx, v1302);
                                                    let v1317 = C::ieee128_constant(ctx, v1316);
                                                    let v1318 = constructor_f128const(ctx, F128, v1317);
                                                    let v1319 = C::subsume(ctx, v1318);
                                                    // Rule at src/opts/cprop.isle line 482.
                                                    returns.extend(Some(v1319));
                                                    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 v1107,
                                            imm: v1108,
                                        } = &v35.1 {
                                            if let &Opcode::F32const = v1107 {
                                                let v1208 = C::f32_ceil(ctx, v1108);
                                                if let Some(v1209) = v1208 {
                                                    let v1210 = constructor_f32const(ctx, F32, v1209);
                                                    let v1211 = C::subsume(ctx, v1210);
                                                    // Rule at src/opts/cprop.isle line 413.
                                                    returns.extend(Some(v1211));
                                                    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 v1113,
                                            imm: v1114,
                                        } = &v35.1 {
                                            if let &Opcode::F64const = v1113 {
                                                let v1212 = C::f64_ceil(ctx, v1114);
                                                if let Some(v1213) = v1212 {
                                                    let v1214 = constructor_f64const(ctx, F64, v1213);
                                                    let v1215 = C::subsume(ctx, v1214);
                                                    // Rule at src/opts/cprop.isle line 416.
                                                    returns.extend(Some(v1215));
                                                    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 v1107,
                                            imm: v1108,
                                        } = &v35.1 {
                                            if let &Opcode::F32const = v1107 {
                                                let v1216 = C::f32_floor(ctx, v1108);
                                                if let Some(v1217) = v1216 {
                                                    let v1218 = constructor_f32const(ctx, F32, v1217);
                                                    let v1219 = C::subsume(ctx, v1218);
                                                    // Rule at src/opts/cprop.isle line 420.
                                                    returns.extend(Some(v1219));
                                                    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 v1113,
                                            imm: v1114,
                                        } = &v35.1 {
                                            if let &Opcode::F64const = v1113 {
                                                let v1220 = C::f64_floor(ctx, v1114);
                                                if let Some(v1221) = v1220 {
                                                    let v1222 = constructor_f64const(ctx, F64, v1221);
                                                    let v1223 = C::subsume(ctx, v1222);
                                                    // Rule at src/opts/cprop.isle line 423.
                                                    returns.extend(Some(v1223));
                                                    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 v1107,
                                            imm: v1108,
                                        } = &v35.1 {
                                            if let &Opcode::F32const = v1107 {
                                                let v1224 = C::f32_trunc(ctx, v1108);
                                                if let Some(v1225) = v1224 {
                                                    let v1226 = constructor_f32const(ctx, F32, v1225);
                                                    let v1227 = C::subsume(ctx, v1226);
                                                    // Rule at src/opts/cprop.isle line 427.
                                                    returns.extend(Some(v1227));
                                                    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 v1113,
                                            imm: v1114,
                                        } = &v35.1 {
                                            if let &Opcode::F64const = v1113 {
                                                let v1228 = C::f64_trunc(ctx, v1114);
                                                if let Some(v1229) = v1228 {
                                                    let v1230 = constructor_f64const(ctx, F64, v1229);
                                                    let v1231 = C::subsume(ctx, v1230);
                                                    // Rule at src/opts/cprop.isle line 430.
                                                    returns.extend(Some(v1231));
                                                    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 v1107,
                                            imm: v1108,
                                        } = &v35.1 {
                                            if let &Opcode::F32const = v1107 {
                                                let v1232 = C::f32_nearest(ctx, v1108);
                                                if let Some(v1233) = v1232 {
                                                    let v1234 = constructor_f32const(ctx, F32, v1233);
                                                    let v1235 = C::subsume(ctx, v1234);
                                                    // Rule at src/opts/cprop.isle line 434.
                                                    returns.extend(Some(v1235));
                                                    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 v1113,
                                            imm: v1114,
                                        } = &v35.1 {
                                            if let &Opcode::F64const = v1113 {
                                                let v1236 = C::f64_nearest(ctx, v1114);
                                                if let Some(v1237) = v1236 {
                                                    let v1238 = constructor_f64const(ctx, F64, v1237);
                                                    let v1239 = C::subsume(ctx, v1238);
                                                    // Rule at src/opts/cprop.isle line 437.
                                                    returns.extend(Some(v1239));
                                                    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 v362,
                                        args: ref v363,
                                        cond: ref v364,
                                    } = &v35.1 {
                                        if let &Opcode::Icmp = v362 {
                                            let v369 = constructor_ineg(ctx, I8, v33);
                                            // Rule at src/opts/bitops.isle line 89.
                                            returns.extend(Some(v369));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                            }
                        }
                        let mut v370 = ContextIterWrapper::<ConstructorVec<_>, _>::default();
                        constructor_truthy(ctx, v33, &mut v370);
                        let mut v370 = v370.into_context_iter();
                        while let Some(v371) = v370.next(ctx) {
                            let v372 = constructor_bmask(ctx, v2.0, v371);
                            // Rule at src/opts/bitops.isle line 111.
                            returns.extend(Some(v372));
                            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 v1383 = constructor_ireduce(ctx, v2.0, v40.0);
                                            let v1384 = constructor_ireduce(ctx, v2.0, v40.1);
                                            let v1385 = constructor_iadd(ctx, v2.0, v1383, v1384);
                                            // Rule at src/opts/extends.isle line 85.
                                            returns.extend(Some(v1385));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Isub => {
                                            let v40 = C::unpack_value_array_2(ctx, v39);
                                            let v1383 = constructor_ireduce(ctx, v2.0, v40.0);
                                            let v1384 = constructor_ireduce(ctx, v2.0, v40.1);
                                            let v1386 = constructor_isub(ctx, v2.0, v1383, v1384);
                                            // Rule at src/opts/extends.isle line 86.
                                            returns.extend(Some(v1386));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Imul => {
                                            let v40 = C::unpack_value_array_2(ctx, v39);
                                            let v1383 = constructor_ireduce(ctx, v2.0, v40.0);
                                            let v1384 = constructor_ireduce(ctx, v2.0, v40.1);
                                            let v1387 = constructor_imul(ctx, v2.0, v1383, v1384);
                                            // Rule at src/opts/extends.isle line 87.
                                            returns.extend(Some(v1387));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Band => {
                                            let v40 = C::unpack_value_array_2(ctx, v39);
                                            let v1383 = constructor_ireduce(ctx, v2.0, v40.0);
                                            let v1384 = constructor_ireduce(ctx, v2.0, v40.1);
                                            let v1390 = constructor_band(ctx, v2.0, v1383, v1384);
                                            // Rule at src/opts/extends.isle line 90.
                                            returns.extend(Some(v1390));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Bor => {
                                            let v40 = C::unpack_value_array_2(ctx, v39);
                                            let v1383 = constructor_ireduce(ctx, v2.0, v40.0);
                                            let v1384 = constructor_ireduce(ctx, v2.0, v40.1);
                                            let v1388 = constructor_bor(ctx, v2.0, v1383, v1384);
                                            // Rule at src/opts/extends.isle line 88.
                                            returns.extend(Some(v1388));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Bxor => {
                                            let v40 = C::unpack_value_array_2(ctx, v39);
                                            let v1383 = constructor_ireduce(ctx, v2.0, v40.0);
                                            let v1384 = constructor_ireduce(ctx, v2.0, v40.1);
                                            let v1389 = constructor_bxor(ctx, v2.0, v1383, v1384);
                                            // Rule at src/opts/extends.isle line 89.
                                            returns.extend(Some(v1389));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v45,
                                    arg: v46,
                                } => {
                                    match v45 {
                                        &Opcode::Ineg => {
                                            let v1380 = constructor_ireduce(ctx, v2.0, v46);
                                            let v1381 = constructor_ineg(ctx, v2.0, v1380);
                                            // Rule at src/opts/extends.isle line 82.
                                            returns.extend(Some(v1381));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Bnot => {
                                            let v1380 = constructor_ireduce(ctx, v2.0, v46);
                                            let v1382 = constructor_bnot(ctx, v2.0, v1380);
                                            // Rule at src/opts/extends.isle line 83.
                                            returns.extend(Some(v1382));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Bmask => {
                                            let v383 = constructor_bmask(ctx, v2.0, v46);
                                            // Rule at src/opts/bitops.isle line 125.
                                            returns.extend(Some(v383));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Uextend => {
                                            let v339 = C::ty_int(ctx, v2.0);
                                            if let Some(v340) = v339 {
                                                let v1366 = C::ty_bits_u64(ctx, v340);
                                                let v1365 = C::value_type(ctx, v46);
                                                let v1367 = C::ty_bits_u64(ctx, v1365);
                                                let v1368 = C::u64_lt(ctx, v1366, v1367);
                                                if v1368 == true {
                                                    let v1369 = constructor_ireduce(ctx, v340, v46);
                                                    // Rule at src/opts/extends.isle line 57.
                                                    returns.extend(Some(v1369));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let v1370 = C::u64_lt(ctx, v1367, v1366);
                                                if v1370 == true {
                                                    let v1372 = constructor_uextend(ctx, v340, v46);
                                                    // Rule at src/opts/extends.isle line 64.
                                                    returns.extend(Some(v1372));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                            let v1365 = C::value_type(ctx, v46);
                                            if v2.0 == v1365 {
                                                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 v339 = C::ty_int(ctx, v2.0);
                                            if let Some(v340) = v339 {
                                                let v1366 = C::ty_bits_u64(ctx, v340);
                                                let v1365 = C::value_type(ctx, v46);
                                                let v1367 = C::ty_bits_u64(ctx, v1365);
                                                let v1368 = C::u64_lt(ctx, v1366, v1367);
                                                if v1368 == true {
                                                    let v1369 = constructor_ireduce(ctx, v340, v46);
                                                    // Rule at src/opts/extends.isle line 54.
                                                    returns.extend(Some(v1369));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let v1370 = C::u64_lt(ctx, v1367, v1366);
                                                if v1370 == true {
                                                    let v1371 = constructor_sextend(ctx, v340, v46);
                                                    // Rule at src/opts/extends.isle line 61.
                                                    returns.extend(Some(v1371));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                            let v1365 = C::value_type(ctx, v46);
                                            if v2.0 == v1365 {
                                                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 v944,
                                    imm: v945,
                                } => {
                                    if let &Opcode::Iconst = v944 {
                                        let v1000 = C::fits_in_64(ctx, v35.0);
                                        if let Some(v1001) = v1000 {
                                            let v1002 = C::u64_from_imm64(ctx, v945);
                                            let v1003 = C::imm64_masked(ctx, v2.0, v1002);
                                            let v1004 = constructor_iconst(ctx, v2.0, v1003);
                                            let v1005 = C::subsume(ctx, v1004);
                                            // Rule at src/opts/cprop.isle line 124.
                                            returns.extend(Some(v1005));
                                            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 v1849 = C::lane_type(ctx, v2.0);
                                    let v2029 = constructor_sextend(ctx, v1849, v46);
                                    let v2030 = constructor_splat(ctx, v2.0, v2029);
                                    // Rule at src/opts/vector.isle line 85.
                                    returns.extend(Some(v2030));
                                    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 v1849 = C::lane_type(ctx, v2.0);
                                    let v2029 = constructor_sextend(ctx, v1849, v46);
                                    let v2030 = constructor_splat(ctx, v2.0, v2029);
                                    // Rule at src/opts/vector.isle line 84.
                                    returns.extend(Some(v2030));
                                    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 v1849 = C::lane_type(ctx, v2.0);
                                    let v2031 = constructor_uextend(ctx, v1849, v46);
                                    let v2032 = constructor_splat(ctx, v2.0, v2031);
                                    // Rule at src/opts/vector.isle line 88.
                                    returns.extend(Some(v2032));
                                    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 v1849 = C::lane_type(ctx, v2.0);
                                    let v2031 = constructor_uextend(ctx, v1849, v46);
                                    let v2032 = constructor_splat(ctx, v2.0, v2031);
                                    // Rule at src/opts/vector.isle line 87.
                                    returns.extend(Some(v2032));
                                    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 v1339 = constructor_uextend(ctx, v2.0, v46);
                                        // Rule at src/opts/extends.isle line 1.
                                        returns.extend(Some(v1339));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v944,
                                    imm: v945,
                                } => {
                                    if let &Opcode::Iconst = v944 {
                                        let v334 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v335) = v334 {
                                            let v1002 = C::u64_from_imm64(ctx, v945);
                                            let v1006 = constructor_iconst_u(ctx, v335, v1002);
                                            let v1007 = C::subsume(ctx, v1006);
                                            // Rule at src/opts/cprop.isle line 129.
                                            returns.extend(Some(v1007));
                                            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 v362,
                                    args: ref v363,
                                    cond: ref v364,
                                } => {
                                    if let &Opcode::Icmp = v362 {
                                        let v1341 = constructor_uextend(ctx, v2.0, v33);
                                        // Rule at src/opts/extends.isle line 11.
                                        returns.extend(Some(v1341));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v45,
                                    arg: v46,
                                } => {
                                    match v45 {
                                        &Opcode::Bmask => {
                                            let v383 = constructor_bmask(ctx, v2.0, v46);
                                            // Rule at src/opts/bitops.isle line 124.
                                            returns.extend(Some(v383));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Uextend => {
                                            let v1339 = constructor_uextend(ctx, v2.0, v46);
                                            // Rule at src/opts/extends.isle line 7.
                                            returns.extend(Some(v1339));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Sextend => {
                                            let v1340 = constructor_sextend(ctx, v2.0, v46);
                                            // Rule at src/opts/extends.isle line 3.
                                            returns.extend(Some(v1340));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        _ => {}
                                    }
                                }
                                _ => {}
                            }
                        }
                        let v334 = C::fits_in_64(ctx, v2.0);
                        if let Some(v335) = v334 {
                            let mut v1008 = C::inst_data_value_tupled_etor_returns::default();
                            C::inst_data_value_tupled_etor(ctx, v33, &mut v1008);
                            let mut v1008 = v1008.into_context_iter();
                            while let Some(v1009) = v1008.next(ctx) {
                                let v1010 = C::iconst_sextend_etor(ctx, v1009);
                                if let Some(v1011) = v1010 {
                                    let v1014 = constructor_iconst_s(ctx, v335, v1011.1);
                                    let v1015 = C::subsume(ctx, v1014);
                                    // Rule at src/opts/cprop.isle line 131.
                                    returns.extend(Some(v1015));
                                    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 v1849 = C::lane_type(ctx, v2.0);
                                            let v1981 = constructor_fcvt_from_uint(ctx, v1849, v46);
                                            let v1982 = constructor_splat(ctx, v2.0, v1981);
                                            // Rule at src/opts/vector.isle line 6.
                                            returns.extend(Some(v1982));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Uextend => {
                                            let v125 = constructor_fcvt_from_uint(ctx, v2.0, v46);
                                            // Rule at src/opts/arithmetic.isle line 217.
                                            returns.extend(Some(v125));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v944,
                                    imm: v945,
                                } => {
                                    if let &Opcode::Iconst = v944 {
                                        match v2.0 {
                                            F32 => {
                                                let v1002 = C::u64_from_imm64(ctx, v945);
                                                let v1139 = C::f32_from_uint(ctx, v1002);
                                                let v1140 = constructor_f32const(ctx, F32, v1139);
                                                // Rule at src/opts/cprop.isle line 336.
                                                returns.extend(Some(v1140));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            F64 => {
                                                let v1002 = C::u64_from_imm64(ctx, v945);
                                                let v1142 = C::f64_from_uint(ctx, v1002);
                                                let v1143 = constructor_f64const(ctx, F64, v1142);
                                                // Rule at src/opts/cprop.isle line 338.
                                                returns.extend(Some(v1143));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            _ => {}
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                    }
                    &Opcode::FcvtFromSint => {
                        match v2.0 {
                            F32 => {
                                let mut v1008 = C::inst_data_value_tupled_etor_returns::default();
                                C::inst_data_value_tupled_etor(ctx, v33, &mut v1008);
                                let mut v1008 = v1008.into_context_iter();
                                while let Some(v1009) = v1008.next(ctx) {
                                    let v1010 = C::iconst_sextend_etor(ctx, v1009);
                                    if let Some(v1011) = v1010 {
                                        let v1144 = C::f32_from_sint(ctx, v1011.1);
                                        let v1145 = constructor_f32const(ctx, F32, v1144);
                                        // Rule at src/opts/cprop.isle line 340.
                                        returns.extend(Some(v1145));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                            }
                            F64 => {
                                let mut v1008 = C::inst_data_value_tupled_etor_returns::default();
                                C::inst_data_value_tupled_etor(ctx, v33, &mut v1008);
                                let mut v1008 = v1008.into_context_iter();
                                while let Some(v1009) = v1008.next(ctx) {
                                    let v1010 = C::iconst_sextend_etor(ctx, v1009);
                                    if let Some(v1011) = v1010 {
                                        let v1146 = C::f64_from_sint(ctx, v1011.1);
                                        let v1147 = constructor_f64const(ctx, F64, v1146);
                                        // Rule at src/opts/cprop.isle line 342.
                                        returns.extend(Some(v1147));
                                        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 v1849 = C::lane_type(ctx, v2.0);
                                        let v1983 = constructor_fcvt_from_sint(ctx, v1849, v46);
                                        let v1984 = constructor_splat(ctx, v2.0, v1983);
                                        // Rule at src/opts/vector.isle line 8.
                                        returns.extend(Some(v1984));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                    &Opcode::Sextend => {
                                        let v126 = constructor_fcvt_from_sint(ctx, v2.0, v46);
                                        // Rule at src/opts/arithmetic.isle line 219.
                                        returns.extend(Some(v126));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                    _ => {}
                                }
                            }
                        }
                    }
                    _ => {}
                }
            }
            &InstructionData::UnaryIeee32 {
                opcode: ref v1608,
                imm: v1609,
            } => {
                if let &Opcode::F32const = v1608 {
                    let v1605 = C::remat(ctx, arg0);
                    // Rule at src/opts/remat.isle line 27.
                    returns.extend(Some(v1605));
                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                }
            }
            &InstructionData::UnaryIeee64 {
                opcode: ref v1610,
                imm: v1611,
            } => {
                if let &Opcode::F64const = v1610 {
                    let v1605 = C::remat(ctx, arg0);
                    // Rule at src/opts/remat.isle line 29.
                    returns.extend(Some(v1605));
                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                }
            }
            &InstructionData::UnaryImm {
                opcode: ref v1606,
                imm: v1607,
            } => {
                if let &Opcode::Iconst = v1606 {
                    let v1605 = C::remat(ctx, arg0);
                    // Rule at src/opts/remat.isle line 25.
                    returns.extend(Some(v1605));
                    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 126.
    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 130.
    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 134.
    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 137.
    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 140.
    return v1;
}

// Generated as internal constructor for term replace_with_two.
pub fn constructor_replace_with_two<C: Context>(
    ctx: &mut C,
    arg0: Inst,
    arg1: Inst,
) -> SkeletonInstSimplification {
    let v2 = SkeletonInstSimplification::ReplaceWithTwo {
        first: arg0,
        second: arg1,
    };
    // Rule at src/prelude_opt.isle line 144.
    return v2;
}

// Generated as internal constructor for term simplify_skeleton.
pub fn constructor_simplify_skeleton<C: Context>(
    ctx: &mut C,
    arg0: Inst,
    returns: &mut (impl Extend<SkeletonInstSimplification> + Length),
) -> () {
    let v1 = &C::inst_data_etor(ctx, arg0);
    if let Some(v2) = v1 {
        match v2 {
            &InstructionData::Binary {
                opcode: ref v3,
                args: ref v4,
            } => {
                match v3 {
                    &Opcode::Udiv => {
                        let v5 = C::unpack_value_array_2(ctx, v4);
                        let mut v15 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v5.1, &mut v15);
                        let mut v15 = v15.into_context_iter();
                        while let Some(v16) = v15.next(ctx) {
                            match &v16.1 {
                                &InstructionData::Ternary {
                                    opcode: ref v261,
                                    args: ref v262,
                                } => {
                                    if let &Opcode::Select = v261 {
                                        let v263 = C::unpack_value_array_3(ctx, v262);
                                        let mut v267 = C::inst_data_value_etor_returns::default();
                                        C::inst_data_value_etor(ctx, v263.1, &mut v267);
                                        let mut v267 = v267.into_context_iter();
                                        while let Some(v268) = v267.next(ctx) {
                                            if let &InstructionData::UnaryImm {
                                                opcode: ref v271,
                                                imm: v272,
                                            } = &v268.1 {
                                                if let &Opcode::Iconst = v271 {
                                                    let v273 = C::imm64_power_of_two(ctx, v272);
                                                    if let Some(v274) = v273 {
                                                        if v16.0 == v268.0 {
                                                            let mut v275 = C::inst_data_value_etor_returns::default();
                                                            C::inst_data_value_etor(ctx, v263.2, &mut v275);
                                                            let mut v275 = v275.into_context_iter();
                                                            while let Some(v276) = v275.next(ctx) {
                                                                if let &InstructionData::UnaryImm {
                                                                    opcode: ref v279,
                                                                    imm: v280,
                                                                } = &v276.1 {
                                                                    if let &Opcode::Iconst = v279 {
                                                                        let v281 = C::imm64_power_of_two(ctx, v280);
                                                                        if let Some(v282) = v281 {
                                                                            if v16.0 == v276.0 {
                                                                                let v283 = C::imm64(ctx, v274);
                                                                                let v284 = constructor_iconst(ctx, v16.0, v283);
                                                                                let v285 = C::imm64(ctx, v282);
                                                                                let v286 = constructor_iconst(ctx, v16.0, v285);
                                                                                let v287 = constructor_select(ctx, v16.0, v263.0, v284, v286);
                                                                                let v288 = constructor_ushr(ctx, v16.0, v5.0, v287);
                                                                                let v289 = &constructor_value_to_skeleton_inst_simplification(ctx, v288);
                                                                                // Rule at src/opts/skeleton.isle line 79.
                                                                                returns.extend(Some(v289.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 v242,
                arg: v243,
                table: v244,
            } => {
                if let &Opcode::BrTable = v242 {
                    let mut v245 = C::inst_data_value_etor_returns::default();
                    C::inst_data_value_etor(ctx, v243, &mut v245);
                    let mut v245 = v245.into_context_iter();
                    while let Some(v246) = v245.next(ctx) {
                        if let &InstructionData::UnaryImm {
                            opcode: ref v249,
                            imm: v250,
                        } = &v246.1 {
                            if let &Opcode::Iconst = v249 {
                                let v251 = C::u64_from_imm64(ctx, v250);
                                let v252 = C::resolve_jump_table_entry(ctx, v244, v251);
                                let v253 = constructor_jump(ctx, v252);
                                let v254 = &constructor_inst_to_skeleton_inst_simplification(ctx, v253);
                                // Rule at src/opts/skeleton.isle line 43.
                                returns.extend(Some(v254.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; }
                                        }
                                    }
                                }
                            }
                            _ => {}
                        }
                    }
                    let v152 = C::unpack_block_array_2(ctx, v145);
                    let v230 = &C::block_call_block(ctx, v152.0);
                    let v231 = &C::just_trap_block(ctx, v230);
                    if let Some(v232) = v231 {
                        let v233 = constructor_trapnz(ctx, v144, v232);
                        let v234 = constructor_jump(ctx, v152.1);
                        let v235 = &constructor_replace_with_two(ctx, v233, v234);
                        // Rule at src/opts/skeleton.isle line 32.
                        returns.extend(Some(v235.clone()));
                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                    }
                    let v236 = &C::block_call_block(ctx, v152.1);
                    let v237 = &C::just_trap_block(ctx, v236);
                    if let Some(v238) = v237 {
                        let v239 = constructor_trapz(ctx, v144, v238);
                        let v240 = constructor_jump(ctx, v152.0);
                        let v241 = &constructor_replace_with_two(ctx, v239, v240);
                        // Rule at src/opts/skeleton.isle line 36.
                        returns.extend(Some(v241.clone()));
                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                    }
                    let mut v255 = ContextIterWrapper::<ConstructorVec<_>, _>::default();
                    constructor_truthy(ctx, v144, &mut v255);
                    let mut v255 = v255.into_context_iter();
                    while let Some(v256) = v255.next(ctx) {
                        let v257 = &constructor_replace_branch_cond(ctx, v256);
                        // Rule at src/opts/skeleton.isle line 49.
                        returns.extend(Some(v257.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; }
                                        }
                                    }
                                }
                            }
                        }
                        let mut v258 = ContextIterWrapper::<ConstructorVec<_>, _>::default();
                        constructor_truthy(ctx, v179, &mut v258);
                        let mut v258 = v258.into_context_iter();
                        while let Some(v259) = v258.next(ctx) {
                            let v260 = &constructor_replace_branch_cond(ctx, v259);
                            // Rule at src/opts/skeleton.isle line 52.
                            returns.extend(Some(v260.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; }
                                    }
                                }
                            }
                        }
                        let mut v258 = ContextIterWrapper::<ConstructorVec<_>, _>::default();
                        constructor_truthy(ctx, v179, &mut v258);
                        let mut v258 = v258.into_context_iter();
                        while let Some(v259) = v258.next(ctx) {
                            let v260 = &constructor_replace_branch_cond(ctx, v259);
                            // Rule at src/opts/skeleton.isle line 55.
                            returns.extend(Some(v260.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 198.
        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 197.
        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 191.
                return v12;
            }
        }
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "iconst_s", "src/prelude_opt.isle line 189")
}

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

// 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 234.
        return arg1;
    }
    let v2 = constructor_uextend(ctx, arg0, arg1);
    // Rule at src/prelude_opt.isle line 233.
    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 240.
        return arg1;
    }
    let v2 = constructor_sextend(ctx, arg0, arg1);
    // Rule at src/prelude_opt.isle line 239.
    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 54.
    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 55.
    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 56.
    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 57.
    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 58.
    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 59.
    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 60.
    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 61.
    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 62.
    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 63.
    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 277.
    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 281.
        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 284.
        return v3;
    }
    let v5 = false;
    // Rule at src/prelude_opt.isle line 287.
    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 316.
    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 321.
        return v11;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "apply_div_const_magic_u32_inner", "src/prelude_opt.isle line 320")
}

// 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 346.
                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 337.
                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 336")
}

// 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 360.
            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 366.
                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 359")
}

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

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

// 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 423.
                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 414.
                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 413")
}

// 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 437.
            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 443.
                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 436")
}

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

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

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

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

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

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

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

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

// 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 341.
    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 350.
    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 359.
    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 368.
    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 377.
    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 386.
    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 395.
    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 404.
    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 413.
    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 422.
    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 431.
    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 440.
    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 449.
    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 458.
    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 467.
    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 476.
    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 485.
    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 494.
    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 503.
    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 512.
    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 521.
    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 530.
    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 539.
    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 548.
    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 557.
    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 566.
    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 575.
    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 584.
    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 593.
    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 602.
    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 611.
    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 620.
    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 629.
    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 638.
    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 647.
    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 656.
    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 665.
    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 674.
    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 683.
    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 692.
    return v6;
}

// 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::StackAddr {
        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 701.
    return v5;
}

// 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::DynamicStackAddr {
        opcode: Opcode::DynamicStackAddr,
        dynamic_stack_slot: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 710.
    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 719.
    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 728.
    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 737.
    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 746.
    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 755.
    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 764.
    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 773.
    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 782.
    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 791.
    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 800.
    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 809.
    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 818.
    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 827.
    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 836.
    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 845.
    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 854.
    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 863.
    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 872.
    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 881.
    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 890.
    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 899.
    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 908.
    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 917.
    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 926.
    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 935.
    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 944.
    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 953.
    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 962.
    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 971.
    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 980.
    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 989.
    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 998.
    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 1007.
    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 1016.
    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 1025.
    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 1034.
    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 1043.
    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 1052.
    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 1061.
    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 1070.
    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 1079.
    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 1088.
    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 1097.
    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 1106.
    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 1115.
    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 1124.
    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 1133.
    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 1142.
    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 1151.
    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 1160.
    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 1169.
    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 1178.
    return v4;
}

// 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 1187.
    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 1196.
    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 1205.
    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 1214.
    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 1223.
    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 1232.
    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 1241.
    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 1250.
    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 1259.
    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 1268.
    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 1277.
    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 1286.
    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 1295.
    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 1304.
    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 1313.
    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 1322.
    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 1331.
    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 1340.
    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 1349.
    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 1358.
    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 1367.
    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 1376.
    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 1385.
    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 1394.
    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 1403.
    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 1412.
    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 1421.
    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 1430.
    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 1439.
    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 1448.
    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 1457.
    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 1466.
    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 1475.
    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 1484.
    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 1493.
    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 1502.
    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 1511.
    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 1520.
    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 1529.
    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 1538.
    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 1547.
    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 1556.
    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 1565.
    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 1574.
    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 1583.
    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 1592.
    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 1601.
    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 1610.
    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 1619.
    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 1628.
    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 1637.
    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 1646.
    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 1655.
    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 1664.
    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 1673.
    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 1682.
    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 1691.
    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 1700.
    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 1709.
    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 1718.
    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 1727.
    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 1736.
    return v2;
}
