// 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 scalar_to_vector_const64(&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,
    },
    RemoveDeadStore {
        dead: Inst,
        overwriter: Inst,
    },
}

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

/// Internal type DivConstMagicS64: defined at src/prelude_opt.isle line 302.
#[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 v1077 = constructor_smin(ctx, v2.0, v99.1, v7.1);
                                                                                    let v1078 = constructor_smin(ctx, v2.0, v99.0, v1077);
                                                                                    // Rule at src/opts/cprop.isle line 237.
                                                                                    returns.extend(Some(v1078));
                                                                                    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 v1869 = C::lane_type(ctx, v2.0);
                                                            let v2032 = constructor_smin(ctx, v1869, v30, v27);
                                                            let v2033 = constructor_splat(ctx, v2.0, v2032);
                                                            // Rule at src/opts/vector.isle line 54.
                                                            returns.extend(Some(v2033));
                                                            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 v1003 = C::imm64_smin(ctx, v335, v23, v15);
                                                                let v1004 = constructor_iconst(ctx, v335, v1003);
                                                                let v1005 = C::subsume(ctx, v1004);
                                                                // Rule at src/opts/cprop.isle line 113.
                                                                returns.extend(Some(v1005));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        if v2.0 == v19.0 {
                                            let v1035 = constructor_smin(ctx, v2.0, v7.1, v7.0);
                                            // Rule at src/opts/cprop.isle line 168.
                                            returns.extend(Some(v1035));
                                            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 v1073 = constructor_umin(ctx, v2.0, v99.1, v7.1);
                                                                                    let v1074 = constructor_umin(ctx, v2.0, v99.0, v1073);
                                                                                    // Rule at src/opts/cprop.isle line 231.
                                                                                    returns.extend(Some(v1074));
                                                                                    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 v1869 = C::lane_type(ctx, v2.0);
                                                            let v2034 = constructor_umin(ctx, v1869, v30, v27);
                                                            let v2035 = constructor_splat(ctx, v2.0, v2034);
                                                            // Rule at src/opts/vector.isle line 57.
                                                            returns.extend(Some(v2035));
                                                            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_umin(ctx, v335, v23, v15);
                                                                let v998 = constructor_iconst(ctx, v335, v997);
                                                                let v999 = C::subsume(ctx, v998);
                                                                // Rule at src/opts/cprop.isle line 103.
                                                                returns.extend(Some(v999));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        if v2.0 == v19.0 {
                                            let v1036 = constructor_umin(ctx, v2.0, v7.1, v7.0);
                                            // Rule at src/opts/cprop.isle line 169.
                                            returns.extend(Some(v1036));
                                            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 v1079 = constructor_smax(ctx, v2.0, v99.1, v7.1);
                                                                                    let v1080 = constructor_smax(ctx, v2.0, v99.0, v1079);
                                                                                    // Rule at src/opts/cprop.isle line 240.
                                                                                    returns.extend(Some(v1080));
                                                                                    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 v1869 = C::lane_type(ctx, v2.0);
                                                            let v2036 = constructor_smax(ctx, v1869, v30, v27);
                                                            let v2037 = constructor_splat(ctx, v2.0, v2036);
                                                            // Rule at src/opts/vector.isle line 60.
                                                            returns.extend(Some(v2037));
                                                            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 v1006 = C::imm64_smax(ctx, v335, v23, v15);
                                                                let v1007 = constructor_iconst(ctx, v335, v1006);
                                                                let v1008 = C::subsume(ctx, v1007);
                                                                // Rule at src/opts/cprop.isle line 118.
                                                                returns.extend(Some(v1008));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        if v2.0 == v19.0 {
                                            let v1037 = constructor_smax(ctx, v2.0, v7.1, v7.0);
                                            // Rule at src/opts/cprop.isle line 170.
                                            returns.extend(Some(v1037));
                                            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 v1075 = constructor_umax(ctx, v2.0, v99.1, v7.1);
                                                                                    let v1076 = constructor_umax(ctx, v2.0, v99.0, v1075);
                                                                                    // Rule at src/opts/cprop.isle line 234.
                                                                                    returns.extend(Some(v1076));
                                                                                    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 v1869 = C::lane_type(ctx, v2.0);
                                                            let v2038 = constructor_umax(ctx, v1869, v30, v27);
                                                            let v2039 = constructor_splat(ctx, v2.0, v2038);
                                                            // Rule at src/opts/vector.isle line 63.
                                                            returns.extend(Some(v2039));
                                                            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 v1000 = C::imm64_umax(ctx, v335, v23, v15);
                                                                let v1001 = constructor_iconst(ctx, v335, v1000);
                                                                let v1002 = C::subsume(ctx, v1001);
                                                                // Rule at src/opts/cprop.isle line 108.
                                                                returns.extend(Some(v1002));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        if v2.0 == v19.0 {
                                            let v1038 = constructor_umax(ctx, v2.0, v7.1, v7.0);
                                            // Rule at src/opts/cprop.isle line 171.
                                            returns.extend(Some(v1038));
                                            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 v1148,
                                                                                            imm: v1149,
                                                                                        } = &v259.1 {
                                                                                            if let &Opcode::Iconst = v1148 {
                                                                                                let v254 = constructor_iadd(ctx, v2.0, v99.0, v135.0);
                                                                                                let v1150 = constructor_iadd(ctx, v2.0, v99.1, v135.1);
                                                                                                let v1151 = constructor_iadd(ctx, v2.0, v254, v1150);
                                                                                                // Rule at src/opts/cprop.isle line 332.
                                                                                                returns.extend(Some(v1151));
                                                                                                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 216.
                                                                            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 213.
                                                                            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 217.
                                                                            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 v644 = constructor_bnot(ctx, v2.0, v30);
                                                                        let v676 = constructor_band(ctx, v2.0, v135.1, v644);
                                                                        // Rule at src/opts/bitops.isle line 253.
                                                                        returns.extend(Some(v676));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v30 == v135.1 {
                                                                        let v644 = constructor_bnot(ctx, v2.0, v30);
                                                                        let v674 = constructor_band(ctx, v2.0, v135.0, v644);
                                                                        // Rule at src/opts/bitops.isle line 249.
                                                                        returns.extend(Some(v674));
                                                                        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 212.
                                                                        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 v1926 = constructor_ishl(ctx, v2.0, v254, v99.1);
                                                                    // Rule at src/opts/shifts.isle line 314.
                                                                    returns.extend(Some(v1926));
                                                                    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 v1869 = C::lane_type(ctx, v2.0);
                                                                let v2016 = constructor_iadd(ctx, v1869, v30, v27);
                                                                let v2017 = constructor_splat(ctx, v2.0, v2016);
                                                                // Rule at src/opts/vector.isle line 30.
                                                                returns.extend(Some(v2017));
                                                                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 v642 = constructor_bnot(ctx, v2.0, v99.0);
                                                                        let v675 = constructor_band(ctx, v2.0, v99.1, v642);
                                                                        // Rule at src/opts/bitops.isle line 251.
                                                                        returns.extend(Some(v675));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v27 == v99.1 {
                                                                        let v672 = constructor_bnot(ctx, v2.0, v99.1);
                                                                        let v673 = constructor_band(ctx, v2.0, v99.0, v672);
                                                                        // Rule at src/opts/bitops.isle line 247.
                                                                        returns.extend(Some(v673));
                                                                        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 v1041 = constructor_iadd(ctx, v2.0, v99.1, v7.1);
                                                                                    let v1042 = constructor_iadd(ctx, v2.0, v99.0, v1041);
                                                                                    // Rule at src/opts/cprop.isle line 182.
                                                                                    returns.extend(Some(v1042));
                                                                                    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 v1046,
                                                                            imm: v1047,
                                                                        } = &v103.1 {
                                                                            if let &Opcode::Iconst = v1046 {
                                                                                if v2.0 == v103.0 {
                                                                                    let v1055 = C::imm64_add(ctx, v2.0, v1047, v15);
                                                                                    let v1056 = constructor_iconst(ctx, v2.0, v1055);
                                                                                    let v1057 = constructor_isub(ctx, v2.0, v1056, v99.1);
                                                                                    // Rule at src/opts/cprop.isle line 208.
                                                                                    returns.extend(Some(v1057));
                                                                                    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 v1051 = C::imm64_sub(ctx, v2.0, v15, v128);
                                                                                    let v1052 = constructor_iconst(ctx, v2.0, v1051);
                                                                                    let v1054 = constructor_iadd(ctx, v2.0, v99.0, v1052);
                                                                                    // Rule at src/opts/cprop.isle line 204.
                                                                                    returns.extend(Some(v1054));
                                                                                    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 v1689,
                                                        args: ref v1690,
                                                    } => {
                                                        if let &Opcode::Select = v1689 {
                                                            if v2.0 == v19.0 {
                                                                let v1691 = C::unpack_value_array_3(ctx, v1690);
                                                                let mut v1695 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v1691.1, &mut v1695);
                                                                let mut v1695 = v1695.into_context_iter();
                                                                while let Some(v1696) = v1695.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v1699,
                                                                        imm: v1700,
                                                                    } = &v1696.1 {
                                                                        if let &Opcode::Iconst = v1699 {
                                                                            if v2.0 == v1696.0 {
                                                                                let mut v1701 = C::inst_data_value_etor_returns::default();
                                                                                C::inst_data_value_etor(ctx, v1691.2, &mut v1701);
                                                                                let mut v1701 = v1701.into_context_iter();
                                                                                while let Some(v1702) = v1701.next(ctx) {
                                                                                    if let &InstructionData::UnaryImm {
                                                                                        opcode: ref v1705,
                                                                                        imm: v1706,
                                                                                    } = &v1702.1 {
                                                                                        if let &Opcode::Iconst = v1705 {
                                                                                            if v2.0 == v1702.0 {
                                                                                                let v1707 = C::imm64_add(ctx, v2.0, v1700, v15);
                                                                                                let v1708 = constructor_iconst(ctx, v2.0, v1707);
                                                                                                let v1709 = C::imm64_add(ctx, v2.0, v1706, v15);
                                                                                                let v1710 = constructor_iconst(ctx, v2.0, v1709);
                                                                                                let v1711 = constructor_select(ctx, v2.0, v1691.0, v1708, v1710);
                                                                                                // Rule at src/opts/selects.isle line 95.
                                                                                                returns.extend(Some(v1711));
                                                                                                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 v961 = C::imm64_add(ctx, v335, v23, v15);
                                                                let v962 = constructor_iconst(ctx, v335, v961);
                                                                let v963 = C::subsume(ctx, v962);
                                                                // Rule at src/opts/cprop.isle line 13.
                                                                returns.extend(Some(v963));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        let v1625 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 5.
                                        returns.extend(Some(v1625));
                                        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 v1028 = constructor_iadd(ctx, v2.0, v7.1, v7.0);
                                            // Rule at src/opts/cprop.isle line 146.
                                            returns.extend(Some(v1028));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        let v1625 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 3.
                                        returns.extend(Some(v1625));
                                        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 v1051 = C::imm64_sub(ctx, v2.0, v15, v128);
                                                                                    let v1052 = constructor_iconst(ctx, v2.0, v1051);
                                                                                    let v1053 = constructor_isub(ctx, v2.0, v99.0, v1052);
                                                                                    // Rule at src/opts/cprop.isle line 200.
                                                                                    returns.extend(Some(v1053));
                                                                                    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 v1046,
                                                                            imm: v1047,
                                                                        } = &v103.1 {
                                                                            if let &Opcode::Iconst = v1046 {
                                                                                if v2.0 == v103.0 {
                                                                                    let v1048 = C::imm64_sub(ctx, v2.0, v1047, v15);
                                                                                    let v1049 = constructor_iconst(ctx, v2.0, v1048);
                                                                                    let v1050 = constructor_isub(ctx, v2.0, v1049, v99.1);
                                                                                    // Rule at src/opts/cprop.isle line 196.
                                                                                    returns.extend(Some(v1050));
                                                                                    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 v1043 = C::imm64_add(ctx, v2.0, v128, v15);
                                                                                    let v1044 = constructor_iconst(ctx, v2.0, v1043);
                                                                                    let v1045 = constructor_isub(ctx, v2.0, v99.0, v1044);
                                                                                    // Rule at src/opts/cprop.isle line 192.
                                                                                    returns.extend(Some(v1045));
                                                                                    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 v877 = constructor_bxor(ctx, v2.0, v99.0, v114);
                                                                                        let v878 = constructor_isub(ctx, v2.0, v877, v114);
                                                                                        // Rule at src/opts/bitops.isle line 546.
                                                                                        returns.extend(Some(v878));
                                                                                        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 v636,
                                                                            arg: v637,
                                                                        } = &v259.1 {
                                                                            if let &Opcode::Bnot = v636 {
                                                                                if v99.1 == v637 {
                                                                                    if v2.0 == v259.0 {
                                                                                        let v238 = constructor_bxor(ctx, v2.0, v99.0, v99.1);
                                                                                        let v881 = constructor_isub(ctx, v2.0, v99.1, v238);
                                                                                        // Rule at src/opts/bitops.isle line 550.
                                                                                        returns.extend(Some(v881));
                                                                                        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 v877 = constructor_bxor(ctx, v2.0, v99.0, v114);
                                                                                        let v878 = constructor_isub(ctx, v2.0, v877, v114);
                                                                                        // Rule at src/opts/bitops.isle line 547.
                                                                                        returns.extend(Some(v878));
                                                                                        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 v639,
                                                                            arg: v640,
                                                                        } = &v275.1 {
                                                                            if let &Opcode::Bnot = v639 {
                                                                                if v99.1 == v640 {
                                                                                    if v2.0 == v275.0 {
                                                                                        let v238 = constructor_bxor(ctx, v2.0, v99.0, v99.1);
                                                                                        let v881 = constructor_isub(ctx, v2.0, v99.1, v238);
                                                                                        // Rule at src/opts/bitops.isle line 551.
                                                                                        returns.extend(Some(v881));
                                                                                        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 v879 = constructor_bxor(ctx, v2.0, v99.1, v107);
                                                                                        let v880 = constructor_isub(ctx, v2.0, v879, v107);
                                                                                        // Rule at src/opts/bitops.isle line 548.
                                                                                        returns.extend(Some(v880));
                                                                                        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 v636,
                                                                            arg: v637,
                                                                        } = &v259.1 {
                                                                            if let &Opcode::Bnot = v636 {
                                                                                if v99.0 == v637 {
                                                                                    if v2.0 == v259.0 {
                                                                                        let v239 = constructor_bxor(ctx, v2.0, v99.1, v99.0);
                                                                                        let v882 = constructor_isub(ctx, v2.0, v99.0, v239);
                                                                                        // Rule at src/opts/bitops.isle line 552.
                                                                                        returns.extend(Some(v882));
                                                                                        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 v879 = constructor_bxor(ctx, v2.0, v99.1, v107);
                                                                                        let v880 = constructor_isub(ctx, v2.0, v879, v107);
                                                                                        // Rule at src/opts/bitops.isle line 549.
                                                                                        returns.extend(Some(v880));
                                                                                        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 v639,
                                                                            arg: v640,
                                                                        } = &v275.1 {
                                                                            if let &Opcode::Bnot = v639 {
                                                                                if v99.0 == v640 {
                                                                                    if v2.0 == v275.0 {
                                                                                        let v239 = constructor_bxor(ctx, v2.0, v99.1, v99.0);
                                                                                        let v882 = constructor_isub(ctx, v2.0, v99.0, v239);
                                                                                        // Rule at src/opts/bitops.isle line 553.
                                                                                        returns.extend(Some(v882));
                                                                                        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 v1925 = constructor_ishl(ctx, v2.0, v248, v99.1);
                                                                    // Rule at src/opts/shifts.isle line 313.
                                                                    returns.extend(Some(v1925));
                                                                    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 v1869 = C::lane_type(ctx, v2.0);
                                                                let v2018 = constructor_isub(ctx, v1869, v30, v27);
                                                                let v2019 = constructor_splat(ctx, v2.0, v2018);
                                                                // Rule at src/opts/vector.isle line 33.
                                                                returns.extend(Some(v2019));
                                                                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 v933 = constructor_isub(ctx, v2.0, v27, v30);
                                                                // Rule at src/opts/bitops.isle line 656.
                                                                returns.extend(Some(v933));
                                                                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 v1029 = constructor_isub(ctx, v2.0, v7.1, v7.0);
                                            let v1030 = constructor_ineg(ctx, v2.0, v1029);
                                            // Rule at src/opts/cprop.isle line 151.
                                            returns.extend(Some(v1030));
                                            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 v964 = C::imm64_sub(ctx, v335, v23, v15);
                                                                let v965 = constructor_iconst(ctx, v335, v964);
                                                                let v966 = C::subsume(ctx, v965);
                                                                // Rule at src/opts/cprop.isle line 19.
                                                                returns.extend(Some(v966));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        let v1625 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 7.
                                        returns.extend(Some(v1625));
                                        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 v1625 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 9.
                                        returns.extend(Some(v1625));
                                        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 v1091 = C::i64_wrapping_neg(ctx, v59.1);
                                let v1092 = C::i64_cast_unsigned(ctx, v1091);
                                let v1093 = C::i64_cast_unsigned(ctx, v59.1);
                                let v1094 = C::u64_lt(ctx, v1092, v1093);
                                if v1094 == true {
                                    if v2.0 == v59.0 {
                                        let v1095 = C::imm64(ctx, v1093);
                                        let v1096 = C::imm64_neg(ctx, v2.0, v1095);
                                        let v1097 = constructor_iconst(ctx, v2.0, v1096);
                                        let v1098 = constructor_iadd(ctx, v2.0, v7.0, v1097);
                                        // Rule at src/opts/cprop.isle line 268.
                                        returns.extend(Some(v1098));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                            }
                        }
                        let mut v343 = C::inst_data_value_tupled_etor_returns::default();
                        C::inst_data_value_tupled_etor(ctx, v7.0, &mut v343);
                        let mut v343 = v343.into_context_iter();
                        while let Some(v344) = v343.next(ctx) {
                            let v345 = C::iconst_sextend_etor(ctx, v344);
                            if let Some(v346) = v345 {
                                if v346.1 == -1_i64 {
                                    if v2.0 == v346.0 {
                                        let v349 = constructor_bnot(ctx, v2.0, v7.1);
                                        // Rule at src/opts/arithmetic.isle line 578.
                                        returns.extend(Some(v349));
                                        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 v1148,
                                                                                    imm: v1149,
                                                                                } = &v259.1 {
                                                                                    if let &Opcode::Iconst = v1148 {
                                                                                        let v1152 = constructor_imul(ctx, v2.0, v99.0, v135.0);
                                                                                        let v1153 = constructor_imul(ctx, v2.0, v99.1, v135.1);
                                                                                        let v1154 = constructor_imul(ctx, v2.0, v1152, v1153);
                                                                                        // Rule at src/opts/cprop.isle line 336.
                                                                                        returns.extend(Some(v1154));
                                                                                        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 v1869 = C::lane_type(ctx, v2.0);
                                                                let v2020 = constructor_imul(ctx, v1869, v30, v27);
                                                                let v2021 = constructor_splat(ctx, v2.0, v2020);
                                                                // Rule at src/opts/vector.isle line 36.
                                                                returns.extend(Some(v2021));
                                                                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 v1058 = constructor_imul(ctx, v2.0, v99.1, v7.1);
                                                                                let v1059 = constructor_imul(ctx, v2.0, v99.0, v1058);
                                                                                // Rule at src/opts/cprop.isle line 213.
                                                                                returns.extend(Some(v1059));
                                                                                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 v967 = C::imm64_mul(ctx, v335, v23, v15);
                                                                    let v968 = constructor_iconst(ctx, v335, v967);
                                                                    let v969 = C::subsume(ctx, v968);
                                                                    // Rule at src/opts/cprop.isle line 25.
                                                                    returns.extend(Some(v969));
                                                                    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 v1031 = constructor_imul(ctx, v2.0, v7.1, v7.0);
                                        // Rule at src/opts/cprop.isle line 154.
                                        returns.extend(Some(v1031));
                                        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 v1869 = C::lane_type(ctx, v2.0);
                                                        let v2024 = constructor_umulhi(ctx, v1869, v30, v27);
                                                        let v2025 = constructor_splat(ctx, v2.0, v2024);
                                                        // Rule at src/opts/vector.isle line 42.
                                                        returns.extend(Some(v2025));
                                                        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 v1869 = C::lane_type(ctx, v2.0);
                                                        let v2022 = constructor_smulhi(ctx, v1869, v30, v27);
                                                        let v2023 = constructor_splat(ctx, v2.0, v2022);
                                                        // Rule at src/opts/vector.isle line 39.
                                                        returns.extend(Some(v2023));
                                                        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 v632 = constructor_band(ctx, v2.0, v7.0, v135.1);
                                                    // Rule at src/opts/bitops.isle line 202.
                                                    returns.extend(Some(v632));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.0 == v135.1 {
                                                    let v633 = constructor_band(ctx, v2.0, v135.0, v7.0);
                                                    // Rule at src/opts/bitops.isle line 203.
                                                    returns.extend(Some(v633));
                                                    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 v1148,
                                                                                    imm: v1149,
                                                                                } = &v259.1 {
                                                                                    if let &Opcode::Iconst = v1148 {
                                                                                        let v677 = constructor_band(ctx, v2.0, v99.0, v135.0);
                                                                                        let v1155 = constructor_band(ctx, v2.0, v99.1, v135.1);
                                                                                        let v1156 = constructor_band(ctx, v2.0, v677, v1155);
                                                                                        // Rule at src/opts/cprop.isle line 340.
                                                                                        returns.extend(Some(v1156));
                                                                                        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 483.
                                                                                            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 v636,
                                                                                arg: v637,
                                                                            } = &v259.1 {
                                                                                if let &Opcode::Bnot = v636 {
                                                                                    if v99.1 == v637 {
                                                                                        if v2.0 == v259.0 {
                                                                                            // Rule at src/opts/bitops.isle line 482.
                                                                                            returns.extend(Some(v99.0));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let v689 = constructor_band(ctx, v2.0, v99.1, v135.1);
                                                                        let v690 = constructor_bor(ctx, v2.0, v689, v99.0);
                                                                        // Rule at src/opts/bitops.isle line 269.
                                                                        returns.extend(Some(v690));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        let v691 = constructor_band(ctx, v2.0, v135.1, v99.1);
                                                                        let v692 = constructor_bor(ctx, v2.0, v691, v99.0);
                                                                        // Rule at src/opts/bitops.isle line 270.
                                                                        returns.extend(Some(v692));
                                                                        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 487.
                                                                                            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 v639,
                                                                                arg: v640,
                                                                            } = &v275.1 {
                                                                                if let &Opcode::Bnot = v639 {
                                                                                    if v99.1 == v640 {
                                                                                        if v2.0 == v275.0 {
                                                                                            // Rule at src/opts/bitops.isle line 484.
                                                                                            returns.extend(Some(v99.0));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let v683 = constructor_band(ctx, v2.0, v135.0, v99.1);
                                                                        let v684 = constructor_bor(ctx, v2.0, v683, v99.0);
                                                                        // Rule at src/opts/bitops.isle line 266.
                                                                        returns.extend(Some(v684));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        let v685 = constructor_band(ctx, v2.0, v99.1, v135.0);
                                                                        let v686 = constructor_bor(ctx, v2.0, v685, v99.0);
                                                                        // Rule at src/opts/bitops.isle line 267.
                                                                        returns.extend(Some(v686));
                                                                        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 485.
                                                                                            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 v636,
                                                                                arg: v637,
                                                                            } = &v259.1 {
                                                                                if let &Opcode::Bnot = v636 {
                                                                                    if v99.0 == v637 {
                                                                                        if v2.0 == v259.0 {
                                                                                            // Rule at src/opts/bitops.isle line 486.
                                                                                            returns.extend(Some(v99.1));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let v681 = constructor_band(ctx, v2.0, v99.0, v135.1);
                                                                        let v682 = constructor_bor(ctx, v2.0, v681, v99.1);
                                                                        // Rule at src/opts/bitops.isle line 265.
                                                                        returns.extend(Some(v682));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        let v687 = constructor_band(ctx, v2.0, v135.1, v99.0);
                                                                        let v688 = constructor_bor(ctx, v2.0, v687, v99.1);
                                                                        // Rule at src/opts/bitops.isle line 268.
                                                                        returns.extend(Some(v688));
                                                                        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 489.
                                                                                            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 v639,
                                                                                arg: v640,
                                                                            } = &v275.1 {
                                                                                if let &Opcode::Bnot = v639 {
                                                                                    if v99.0 == v640 {
                                                                                        if v2.0 == v275.0 {
                                                                                            // Rule at src/opts/bitops.isle line 488.
                                                                                            returns.extend(Some(v99.1));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let v677 = constructor_band(ctx, v2.0, v99.0, v135.0);
                                                                        let v678 = constructor_bor(ctx, v2.0, v677, v99.1);
                                                                        // Rule at src/opts/bitops.isle line 263.
                                                                        returns.extend(Some(v678));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        let v679 = constructor_band(ctx, v2.0, v135.0, v99.0);
                                                                        let v680 = constructor_bor(ctx, v2.0, v679, v99.1);
                                                                        // Rule at src/opts/bitops.isle line 264.
                                                                        returns.extend(Some(v680));
                                                                        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 v658 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v30, &mut v658);
                                                                    let mut v658 = v658.into_context_iter();
                                                                    while let Some(v659) = v658.next(ctx) {
                                                                        if let &InstructionData::Binary {
                                                                            opcode: ref v662,
                                                                            args: ref v663,
                                                                        } = &v659.1 {
                                                                            match v662 {
                                                                                &Opcode::Band => {
                                                                                    if v2.0 == v659.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 v636,
                                                                                                arg: v637,
                                                                                            } = &v259.1 {
                                                                                                if let &Opcode::Bnot = v636 {
                                                                                                    if v2.0 == v259.0 {
                                                                                                        let v664 = C::unpack_value_array_2(ctx, v663);
                                                                                                        if v135.0 == v664.0 {
                                                                                                            if v637 == v664.1 {
                                                                                                                let v747 = constructor_bnot(ctx, v2.0, v664.1);
                                                                                                                // Rule at src/opts/bitops.isle line 676.
                                                                                                                returns.extend(Some(v747));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                        if v637 == v664.0 {
                                                                                                            if v135.0 == v664.1 {
                                                                                                                let v743 = constructor_bnot(ctx, v2.0, v664.0);
                                                                                                                // Rule at src/opts/bitops.isle line 674.
                                                                                                                returns.extend(Some(v743));
                                                                                                                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 v639,
                                                                                                arg: v640,
                                                                                            } = &v275.1 {
                                                                                                if let &Opcode::Bnot = v639 {
                                                                                                    if v2.0 == v275.0 {
                                                                                                        let v664 = C::unpack_value_array_2(ctx, v663);
                                                                                                        if v135.1 == v664.0 {
                                                                                                            if v640 == v664.1 {
                                                                                                                let v747 = constructor_bnot(ctx, v2.0, v664.1);
                                                                                                                // Rule at src/opts/bitops.isle line 672.
                                                                                                                returns.extend(Some(v747));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                        if v640 == v664.0 {
                                                                                                            if v135.1 == v664.1 {
                                                                                                                let v743 = constructor_bnot(ctx, v2.0, v664.0);
                                                                                                                // Rule at src/opts/bitops.isle line 670.
                                                                                                                returns.extend(Some(v743));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                                &Opcode::Bxor => {
                                                                                    if v2.0 == v659.0 {
                                                                                        let v135 = C::unpack_value_array_2(ctx, v134);
                                                                                        let v664 = C::unpack_value_array_2(ctx, v663);
                                                                                        if v135.0 == v664.0 {
                                                                                            if v135.1 == v664.1 {
                                                                                                let v891 = constructor_band(ctx, v2.0, v664.0, v664.1);
                                                                                                // Rule at src/opts/bitops.isle line 589.
                                                                                                returns.extend(Some(v891));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v892 = constructor_band(ctx, v2.0, v664.1, v664.0);
                                                                                                // Rule at src/opts/bitops.isle line 595.
                                                                                                returns.extend(Some(v892));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                        if v135.0 == v664.1 {
                                                                                            if v135.1 == v664.0 {
                                                                                                let v892 = constructor_band(ctx, v2.0, v664.1, v664.0);
                                                                                                // Rule at src/opts/bitops.isle line 591.
                                                                                                returns.extend(Some(v892));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v891 = constructor_band(ctx, v2.0, v664.0, v664.1);
                                                                                                // Rule at src/opts/bitops.isle line 593.
                                                                                                returns.extend(Some(v891));
                                                                                                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 v857 = constructor_bor(ctx, v2.0, v135.0, v264.1);
                                                                        let v858 = constructor_band(ctx, v2.0, v857, v7.0);
                                                                        // Rule at src/opts/bitops.isle line 515.
                                                                        returns.extend(Some(v858));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v7.0 == v264.1 {
                                                                        let v865 = constructor_bor(ctx, v2.0, v135.0, v264.0);
                                                                        let v866 = constructor_band(ctx, v2.0, v865, v7.0);
                                                                        // Rule at src/opts/bitops.isle line 519.
                                                                        returns.extend(Some(v866));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v636,
                                                            arg: v637,
                                                        } => {
                                                            if let &Opcode::Bnot = v636 {
                                                                if v7.0 == v637 {
                                                                    if v2.0 == v259.0 {
                                                                        let v873 = constructor_band(ctx, v2.0, v7.0, v135.0);
                                                                        // Rule at src/opts/bitops.isle line 536.
                                                                        returns.extend(Some(v873));
                                                                        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 v861 = constructor_bor(ctx, v2.0, v135.1, v280.1);
                                                                        let v862 = constructor_band(ctx, v2.0, v861, v7.0);
                                                                        // Rule at src/opts/bitops.isle line 517.
                                                                        returns.extend(Some(v862));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v7.0 == v280.1 {
                                                                        let v869 = constructor_bor(ctx, v2.0, v135.1, v280.0);
                                                                        let v870 = constructor_band(ctx, v2.0, v869, v7.0);
                                                                        // Rule at src/opts/bitops.isle line 521.
                                                                        returns.extend(Some(v870));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v639,
                                                            arg: v640,
                                                        } => {
                                                            if let &Opcode::Bnot = v639 {
                                                                if v7.0 == v640 {
                                                                    if v2.0 == v275.0 {
                                                                        let v632 = constructor_band(ctx, v2.0, v7.0, v135.1);
                                                                        // Rule at src/opts/bitops.isle line 534.
                                                                        returns.extend(Some(v632));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                if v7.0 == v135.0 {
                                                    // Rule at src/opts/bitops.isle line 258.
                                                    returns.extend(Some(v7.0));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.0 == v135.1 {
                                                    // Rule at src/opts/bitops.isle line 260.
                                                    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 v906 = constructor_bxor(ctx, v2.0, v99.0, v270.0);
                                                                                        let v907 = constructor_bnot(ctx, v2.0, v270.1);
                                                                                        let v908 = constructor_band(ctx, v2.0, v906, v907);
                                                                                        // Rule at src/opts/bitops.isle line 635.
                                                                                        returns.extend(Some(v908));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v135.1 == v270.1 {
                                                                                        let v916 = constructor_bxor(ctx, v2.0, v99.0, v270.1);
                                                                                        let v917 = constructor_bnot(ctx, v2.0, v270.0);
                                                                                        let v918 = constructor_band(ctx, v2.0, v916, v917);
                                                                                        // Rule at src/opts/bitops.isle line 639.
                                                                                        returns.extend(Some(v918));
                                                                                        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 v904 = constructor_bnot(ctx, v2.0, v264.1);
                                                                                        let v905 = constructor_band(ctx, v2.0, v238, v904);
                                                                                        // Rule at src/opts/bitops.isle line 634.
                                                                                        returns.extend(Some(v905));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v99.1 == v264.1 {
                                                                                        let v238 = constructor_bxor(ctx, v2.0, v99.0, v99.1);
                                                                                        let v914 = constructor_bnot(ctx, v2.0, v264.0);
                                                                                        let v915 = constructor_band(ctx, v2.0, v238, v914);
                                                                                        // Rule at src/opts/bitops.isle line 638.
                                                                                        returns.extend(Some(v915));
                                                                                        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 v906 = constructor_bxor(ctx, v2.0, v99.0, v270.0);
                                                                                        let v907 = constructor_bnot(ctx, v2.0, v270.1);
                                                                                        let v908 = constructor_band(ctx, v2.0, v906, v907);
                                                                                        // Rule at src/opts/bitops.isle line 643.
                                                                                        returns.extend(Some(v908));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v135.0 == v270.1 {
                                                                                        let v916 = constructor_bxor(ctx, v2.0, v99.0, v270.1);
                                                                                        let v917 = constructor_bnot(ctx, v2.0, v270.0);
                                                                                        let v918 = constructor_band(ctx, v2.0, v916, v917);
                                                                                        // Rule at src/opts/bitops.isle line 647.
                                                                                        returns.extend(Some(v918));
                                                                                        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 v899 = constructor_bnot(ctx, v2.0, v280.1);
                                                                                        let v900 = constructor_band(ctx, v2.0, v238, v899);
                                                                                        // Rule at src/opts/bitops.isle line 632.
                                                                                        returns.extend(Some(v900));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v99.1 == v280.1 {
                                                                                        let v238 = constructor_bxor(ctx, v2.0, v99.0, v99.1);
                                                                                        let v909 = constructor_bnot(ctx, v2.0, v280.0);
                                                                                        let v910 = constructor_band(ctx, v2.0, v238, v909);
                                                                                        // Rule at src/opts/bitops.isle line 636.
                                                                                        returns.extend(Some(v910));
                                                                                        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 v901 = constructor_bxor(ctx, v2.0, v99.1, v286.0);
                                                                                        let v902 = constructor_bnot(ctx, v2.0, v286.1);
                                                                                        let v903 = constructor_band(ctx, v2.0, v901, v902);
                                                                                        // Rule at src/opts/bitops.isle line 633.
                                                                                        returns.extend(Some(v903));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v135.1 == v286.1 {
                                                                                        let v911 = constructor_bxor(ctx, v2.0, v99.1, v286.1);
                                                                                        let v912 = constructor_bnot(ctx, v2.0, v286.0);
                                                                                        let v913 = constructor_band(ctx, v2.0, v911, v912);
                                                                                        // Rule at src/opts/bitops.isle line 637.
                                                                                        returns.extend(Some(v913));
                                                                                        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 v904 = constructor_bnot(ctx, v2.0, v264.1);
                                                                                        let v920 = constructor_band(ctx, v2.0, v239, v904);
                                                                                        // Rule at src/opts/bitops.isle line 642.
                                                                                        returns.extend(Some(v920));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v99.0 == v264.1 {
                                                                                        let v239 = constructor_bxor(ctx, v2.0, v99.1, v99.0);
                                                                                        let v914 = constructor_bnot(ctx, v2.0, v264.0);
                                                                                        let v922 = constructor_band(ctx, v2.0, v239, v914);
                                                                                        // Rule at src/opts/bitops.isle line 646.
                                                                                        returns.extend(Some(v922));
                                                                                        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 v901 = constructor_bxor(ctx, v2.0, v99.1, v286.0);
                                                                                        let v902 = constructor_bnot(ctx, v2.0, v286.1);
                                                                                        let v903 = constructor_band(ctx, v2.0, v901, v902);
                                                                                        // Rule at src/opts/bitops.isle line 641.
                                                                                        returns.extend(Some(v903));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v135.0 == v286.1 {
                                                                                        let v911 = constructor_bxor(ctx, v2.0, v99.1, v286.1);
                                                                                        let v912 = constructor_bnot(ctx, v2.0, v286.0);
                                                                                        let v913 = constructor_band(ctx, v2.0, v911, v912);
                                                                                        // Rule at src/opts/bitops.isle line 645.
                                                                                        returns.extend(Some(v913));
                                                                                        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 v899 = constructor_bnot(ctx, v2.0, v280.1);
                                                                                        let v919 = constructor_band(ctx, v2.0, v239, v899);
                                                                                        // Rule at src/opts/bitops.isle line 640.
                                                                                        returns.extend(Some(v919));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v99.0 == v280.1 {
                                                                                        let v239 = constructor_bxor(ctx, v2.0, v99.1, v99.0);
                                                                                        let v909 = constructor_bnot(ctx, v2.0, v280.0);
                                                                                        let v921 = constructor_band(ctx, v2.0, v239, v909);
                                                                                        // Rule at src/opts/bitops.isle line 644.
                                                                                        returns.extend(Some(v921));
                                                                                        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 v636,
                                                        arg: v637,
                                                    } = &v259.1 {
                                                        if let &Opcode::Bnot = v636 {
                                                            if v2.0 == v259.0 {
                                                                if v7.0 == v637 {
                                                                    let v873 = constructor_band(ctx, v2.0, v7.0, v135.0);
                                                                    // Rule at src/opts/bitops.isle line 618.
                                                                    returns.extend(Some(v873));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v7.0 == v135.0 {
                                                                    let v638 = constructor_band(ctx, v2.0, v7.0, v637);
                                                                    // Rule at src/opts/bitops.isle line 208.
                                                                    returns.extend(Some(v638));
                                                                    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 v639,
                                                        arg: v640,
                                                    } = &v275.1 {
                                                        if let &Opcode::Bnot = v639 {
                                                            if v2.0 == v275.0 {
                                                                if v7.0 == v135.1 {
                                                                    let v641 = constructor_band(ctx, v2.0, v7.0, v640);
                                                                    // Rule at src/opts/bitops.isle line 209.
                                                                    returns.extend(Some(v641));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v7.0 == v640 {
                                                                    let v632 = constructor_band(ctx, v2.0, v7.0, v135.1);
                                                                    // Rule at src/opts/bitops.isle line 616.
                                                                    returns.extend(Some(v632));
                                                                    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 v677 = constructor_band(ctx, v2.0, v99.0, v135.0);
                                                                    let v1924 = constructor_ishl(ctx, v2.0, v677, v99.1);
                                                                    // Rule at src/opts/shifts.isle line 312.
                                                                    returns.extend(Some(v1924));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::IntCompare {
                                    opcode: ref v764,
                                    args: ref v765,
                                    cond: ref v766,
                                } => {
                                    if let &Opcode::Icmp = v764 {
                                        let mut v18 = C::inst_data_value_etor_returns::default();
                                        C::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 v758,
                                                args: ref v759,
                                                cond: ref v760,
                                            } = &v19.1 {
                                                if let &Opcode::Icmp = v758 {
                                                    if v11.0 == v19.0 {
                                                        match v760 {
                                                            &IntCC::NotEqual => {
                                                                match v766 {
                                                                    &IntCC::UnsignedGreaterThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v761 = C::unpack_value_array_2(ctx, v759);
                                                                            let v767 = C::unpack_value_array_2(ctx, v765);
                                                                            if v761.0 == v767.1 {
                                                                                let mut v1565 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v761.1, &mut v1565);
                                                                                let mut v1565 = v1565.into_context_iter();
                                                                                while let Some(v1566) = v1565.next(ctx) {
                                                                                    let v1567 = C::iconst_sextend_etor(ctx, v1566);
                                                                                    if let Some(v1568) = v1567 {
                                                                                        if v1568.1 == -1_i64 {
                                                                                            let v1593 = constructor_ult(ctx, v2.0, v761.0, v767.0);
                                                                                            // Rule at src/opts/icmp.isle line 358.
                                                                                            returns.extend(Some(v1593));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            if v761.1 == v767.1 {
                                                                                let mut v1578 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v761.0, &mut v1578);
                                                                                let mut v1578 = v1578.into_context_iter();
                                                                                while let Some(v1579) = v1578.next(ctx) {
                                                                                    let v1580 = C::iconst_sextend_etor(ctx, v1579);
                                                                                    if let Some(v1581) = v1580 {
                                                                                        if v1581.1 == -1_i64 {
                                                                                            let v1595 = constructor_ult(ctx, v2.0, v761.1, v767.0);
                                                                                            // Rule at src/opts/icmp.isle line 364.
                                                                                            returns.extend(Some(v1595));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v761 = C::unpack_value_array_2(ctx, v759);
                                                                            let v767 = C::unpack_value_array_2(ctx, v765);
                                                                            if v761.0 == v767.0 {
                                                                                let mut v1565 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v761.1, &mut v1565);
                                                                                let mut v1565 = v1565.into_context_iter();
                                                                                while let Some(v1566) = v1565.next(ctx) {
                                                                                    let v1567 = C::iconst_sextend_etor(ctx, v1566);
                                                                                    if let Some(v1568) = v1567 {
                                                                                        if v1568.1 == -1_i64 {
                                                                                            let v1594 = constructor_ult(ctx, v2.0, v761.0, v767.1);
                                                                                            // Rule at src/opts/icmp.isle line 361.
                                                                                            returns.extend(Some(v1594));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            if v761.1 == v767.0 {
                                                                                let mut v1578 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v761.0, &mut v1578);
                                                                                let mut v1578 = v1578.into_context_iter();
                                                                                while let Some(v1579) = v1578.next(ctx) {
                                                                                    let v1580 = C::iconst_sextend_etor(ctx, v1579);
                                                                                    if let Some(v1581) = v1580 {
                                                                                        if v1581.1 == -1_i64 {
                                                                                            let v1596 = constructor_ult(ctx, v2.0, v761.1, v767.1);
                                                                                            // Rule at src/opts/icmp.isle line 367.
                                                                                            returns.extend(Some(v1596));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                            &IntCC::SignedGreaterThan => {
                                                                match v766 {
                                                                    &IntCC::SignedLessThan => {
                                                                        let v352 = C::ty_int_vec128(ctx, v2.0);
                                                                        if let Some(v353) = v352 {
                                                                            if v11.0 == v353 {
                                                                                let v761 = C::unpack_value_array_2(ctx, v759);
                                                                                let v767 = C::unpack_value_array_2(ctx, v765);
                                                                                if v761.0 == v767.0 {
                                                                                    if v761.1 == v767.1 {
                                                                                        let v356 = constructor_iconst_u(ctx, v353, 0x0_u64);
                                                                                        // Rule at src/opts/icmp.isle line 319.
                                                                                        returns.extend(Some(v356));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v761 = C::unpack_value_array_2(ctx, v759);
                                                                            let v767 = C::unpack_value_array_2(ctx, v765);
                                                                            if v761.0 == v767.0 {
                                                                                let mut v1565 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v761.1, &mut v1565);
                                                                                let mut v1565 = v1565.into_context_iter();
                                                                                while let Some(v1566) = v1565.next(ctx) {
                                                                                    let v1567 = C::iconst_sextend_etor(ctx, v1566);
                                                                                    if let Some(v1568) = v1567 {
                                                                                        let v1577 = C::i64_gt_eq(ctx, v1568.1, 0_i64);
                                                                                        if v1577 == true {
                                                                                            let mut v1571 = C::inst_data_value_tupled_etor_returns::default();
                                                                                            C::inst_data_value_tupled_etor(ctx, v767.1, &mut v1571);
                                                                                            let mut v1571 = v1571.into_context_iter();
                                                                                            while let Some(v1572) = v1571.next(ctx) {
                                                                                                let v1573 = C::iconst_sextend_etor(ctx, v1572);
                                                                                                if let Some(v1574) = v1573 {
                                                                                                    if v1568.1 == v1574.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 v761.1 == v767.1 {
                                                                                let mut v1578 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v761.0, &mut v1578);
                                                                                let mut v1578 = v1578.into_context_iter();
                                                                                while let Some(v1579) = v1578.next(ctx) {
                                                                                    let v1580 = C::iconst_sextend_etor(ctx, v1579);
                                                                                    if let Some(v1581) = v1580 {
                                                                                        let v1590 = C::i64_lt(ctx, v1581.1, 0_i64);
                                                                                        if v1590 == true {
                                                                                            let mut v1584 = C::inst_data_value_tupled_etor_returns::default();
                                                                                            C::inst_data_value_tupled_etor(ctx, v767.0, &mut v1584);
                                                                                            let mut v1584 = v1584.into_context_iter();
                                                                                            while let Some(v1585) = v1584.next(ctx) {
                                                                                                let v1586 = C::iconst_sextend_etor(ctx, v1585);
                                                                                                if let Some(v1587) = v1586 {
                                                                                                    if v1581.1 == v1587.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 v766 {
                                                                    &IntCC::SignedGreaterThan => {
                                                                        let v352 = C::ty_int_vec128(ctx, v2.0);
                                                                        if let Some(v353) = v352 {
                                                                            if v11.0 == v353 {
                                                                                let v761 = C::unpack_value_array_2(ctx, v759);
                                                                                let v767 = C::unpack_value_array_2(ctx, v765);
                                                                                if v761.0 == v767.0 {
                                                                                    if v761.1 == v767.1 {
                                                                                        let v356 = constructor_iconst_u(ctx, v353, 0x0_u64);
                                                                                        // Rule at src/opts/icmp.isle line 320.
                                                                                        returns.extend(Some(v356));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedGreaterThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v761 = C::unpack_value_array_2(ctx, v759);
                                                                            let v767 = C::unpack_value_array_2(ctx, v765);
                                                                            if v761.0 == v767.0 {
                                                                                let mut v1565 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v761.1, &mut v1565);
                                                                                let mut v1565 = v1565.into_context_iter();
                                                                                while let Some(v1566) = v1565.next(ctx) {
                                                                                    let v1567 = C::iconst_sextend_etor(ctx, v1566);
                                                                                    if let Some(v1568) = v1567 {
                                                                                        let v1591 = C::i64_lt(ctx, v1568.1, 0_i64);
                                                                                        if v1591 == true {
                                                                                            let mut v1571 = C::inst_data_value_tupled_etor_returns::default();
                                                                                            C::inst_data_value_tupled_etor(ctx, v767.1, &mut v1571);
                                                                                            let mut v1571 = v1571.into_context_iter();
                                                                                            while let Some(v1572) = v1571.next(ctx) {
                                                                                                let v1573 = C::iconst_sextend_etor(ctx, v1572);
                                                                                                if let Some(v1574) = v1573 {
                                                                                                    if v1568.1 == v1574.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 v761.1 == v767.1 {
                                                                                let mut v1578 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v761.0, &mut v1578);
                                                                                let mut v1578 = v1578.into_context_iter();
                                                                                while let Some(v1579) = v1578.next(ctx) {
                                                                                    let v1580 = C::iconst_sextend_etor(ctx, v1579);
                                                                                    if let Some(v1581) = v1580 {
                                                                                        let v1592 = C::i64_gt_eq(ctx, v1581.1, 0_i64);
                                                                                        if v1592 == true {
                                                                                            let mut v1584 = C::inst_data_value_tupled_etor_returns::default();
                                                                                            C::inst_data_value_tupled_etor(ctx, v767.0, &mut v1584);
                                                                                            let mut v1584 = v1584.into_context_iter();
                                                                                            while let Some(v1585) = v1584.next(ctx) {
                                                                                                let v1586 = C::iconst_sextend_etor(ctx, v1585);
                                                                                                if let Some(v1587) = v1586 {
                                                                                                    if v1581.1 == v1587.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 v766 {
                                                                    &IntCC::NotEqual => {
                                                                        if v2.0 == v11.0 {
                                                                            let v761 = C::unpack_value_array_2(ctx, v759);
                                                                            let v767 = C::unpack_value_array_2(ctx, v765);
                                                                            if v761.1 == v767.0 {
                                                                                let mut v1571 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v767.1, &mut v1571);
                                                                                let mut v1571 = v1571.into_context_iter();
                                                                                while let Some(v1572) = v1571.next(ctx) {
                                                                                    let v1573 = C::iconst_sextend_etor(ctx, v1572);
                                                                                    if let Some(v1574) = v1573 {
                                                                                        if v1574.1 == -1_i64 {
                                                                                            let v1597 = constructor_ult(ctx, v2.0, v761.1, v761.0);
                                                                                            // Rule at src/opts/icmp.isle line 370.
                                                                                            returns.extend(Some(v1597));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            if v761.1 == v767.1 {
                                                                                let mut v1584 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v767.0, &mut v1584);
                                                                                let mut v1584 = v1584.into_context_iter();
                                                                                while let Some(v1585) = v1584.next(ctx) {
                                                                                    let v1586 = C::iconst_sextend_etor(ctx, v1585);
                                                                                    if let Some(v1587) = v1586 {
                                                                                        if v1587.1 == -1_i64 {
                                                                                            let v1597 = constructor_ult(ctx, v2.0, v761.1, v761.0);
                                                                                            // Rule at src/opts/icmp.isle line 373.
                                                                                            returns.extend(Some(v1597));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedLessThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v761 = C::unpack_value_array_2(ctx, v759);
                                                                            let v767 = C::unpack_value_array_2(ctx, v765);
                                                                            if v761.0 == v767.0 {
                                                                                let mut v1565 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v761.1, &mut v1565);
                                                                                let mut v1565 = v1565.into_context_iter();
                                                                                while let Some(v1566) = v1565.next(ctx) {
                                                                                    let v1567 = C::iconst_sextend_etor(ctx, v1566);
                                                                                    if let Some(v1568) = v1567 {
                                                                                        let v1591 = C::i64_lt(ctx, v1568.1, 0_i64);
                                                                                        if v1591 == true {
                                                                                            let mut v1571 = C::inst_data_value_tupled_etor_returns::default();
                                                                                            C::inst_data_value_tupled_etor(ctx, v767.1, &mut v1571);
                                                                                            let mut v1571 = v1571.into_context_iter();
                                                                                            while let Some(v1572) = v1571.next(ctx) {
                                                                                                let v1573 = C::iconst_sextend_etor(ctx, v1572);
                                                                                                if let Some(v1574) = v1573 {
                                                                                                    if v1568.1 == v1574.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 v761.1 == v767.1 {
                                                                                let mut v1578 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v761.0, &mut v1578);
                                                                                let mut v1578 = v1578.into_context_iter();
                                                                                while let Some(v1579) = v1578.next(ctx) {
                                                                                    let v1580 = C::iconst_sextend_etor(ctx, v1579);
                                                                                    if let Some(v1581) = v1580 {
                                                                                        let v1592 = C::i64_gt_eq(ctx, v1581.1, 0_i64);
                                                                                        if v1592 == true {
                                                                                            let mut v1584 = C::inst_data_value_tupled_etor_returns::default();
                                                                                            C::inst_data_value_tupled_etor(ctx, v767.0, &mut v1584);
                                                                                            let mut v1584 = v1584.into_context_iter();
                                                                                            while let Some(v1585) = v1584.next(ctx) {
                                                                                                let v1586 = C::iconst_sextend_etor(ctx, v1585);
                                                                                                if let Some(v1587) = v1586 {
                                                                                                    if v1581.1 == v1587.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 v352 = C::ty_int_vec128(ctx, v2.0);
                                                                        if let Some(v353) = v352 {
                                                                            if v11.0 == v353 {
                                                                                let v761 = C::unpack_value_array_2(ctx, v759);
                                                                                let v767 = C::unpack_value_array_2(ctx, v765);
                                                                                if v761.0 == v767.0 {
                                                                                    if v761.1 == v767.1 {
                                                                                        let v356 = constructor_iconst_u(ctx, v353, 0x0_u64);
                                                                                        // Rule at src/opts/icmp.isle line 321.
                                                                                        returns.extend(Some(v356));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                            &IntCC::UnsignedLessThan => {
                                                                match v766 {
                                                                    &IntCC::NotEqual => {
                                                                        if v2.0 == v11.0 {
                                                                            let v761 = C::unpack_value_array_2(ctx, v759);
                                                                            let v767 = C::unpack_value_array_2(ctx, v765);
                                                                            if v761.0 == v767.0 {
                                                                                let mut v1571 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v767.1, &mut v1571);
                                                                                let mut v1571 = v1571.into_context_iter();
                                                                                while let Some(v1572) = v1571.next(ctx) {
                                                                                    let v1573 = C::iconst_sextend_etor(ctx, v1572);
                                                                                    if let Some(v1574) = v1573 {
                                                                                        if v1574.1 == -1_i64 {
                                                                                            let v1598 = constructor_ult(ctx, v2.0, v761.0, v761.1);
                                                                                            // Rule at src/opts/icmp.isle line 376.
                                                                                            returns.extend(Some(v1598));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            if v761.0 == v767.1 {
                                                                                let mut v1584 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v767.0, &mut v1584);
                                                                                let mut v1584 = v1584.into_context_iter();
                                                                                while let Some(v1585) = v1584.next(ctx) {
                                                                                    let v1586 = C::iconst_sextend_etor(ctx, v1585);
                                                                                    if let Some(v1587) = v1586 {
                                                                                        if v1587.1 == -1_i64 {
                                                                                            let v1598 = constructor_ult(ctx, v2.0, v761.0, v761.1);
                                                                                            // Rule at src/opts/icmp.isle line 379.
                                                                                            returns.extend(Some(v1598));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedGreaterThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v761 = C::unpack_value_array_2(ctx, v759);
                                                                            let v767 = C::unpack_value_array_2(ctx, v765);
                                                                            if v761.0 == v767.0 {
                                                                                let mut v1565 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v761.1, &mut v1565);
                                                                                let mut v1565 = v1565.into_context_iter();
                                                                                while let Some(v1566) = v1565.next(ctx) {
                                                                                    let v1567 = C::iconst_sextend_etor(ctx, v1566);
                                                                                    if let Some(v1568) = v1567 {
                                                                                        let v1577 = C::i64_gt_eq(ctx, v1568.1, 0_i64);
                                                                                        if v1577 == true {
                                                                                            let mut v1571 = C::inst_data_value_tupled_etor_returns::default();
                                                                                            C::inst_data_value_tupled_etor(ctx, v767.1, &mut v1571);
                                                                                            let mut v1571 = v1571.into_context_iter();
                                                                                            while let Some(v1572) = v1571.next(ctx) {
                                                                                                let v1573 = C::iconst_sextend_etor(ctx, v1572);
                                                                                                if let Some(v1574) = v1573 {
                                                                                                    if v1568.1 == v1574.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 v761.1 == v767.1 {
                                                                                let mut v1578 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v761.0, &mut v1578);
                                                                                let mut v1578 = v1578.into_context_iter();
                                                                                while let Some(v1579) = v1578.next(ctx) {
                                                                                    let v1580 = C::iconst_sextend_etor(ctx, v1579);
                                                                                    if let Some(v1581) = v1580 {
                                                                                        let v1590 = C::i64_lt(ctx, v1581.1, 0_i64);
                                                                                        if v1590 == true {
                                                                                            let mut v1584 = C::inst_data_value_tupled_etor_returns::default();
                                                                                            C::inst_data_value_tupled_etor(ctx, v767.0, &mut v1584);
                                                                                            let mut v1584 = v1584.into_context_iter();
                                                                                            while let Some(v1585) = v1584.next(ctx) {
                                                                                                let v1586 = C::iconst_sextend_etor(ctx, v1585);
                                                                                                if let Some(v1587) = v1586 {
                                                                                                    if v1581.1 == v1587.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 v352 = C::ty_int_vec128(ctx, v2.0);
                                                                        if let Some(v353) = v352 {
                                                                            if v11.0 == v353 {
                                                                                let v761 = C::unpack_value_array_2(ctx, v759);
                                                                                let v767 = C::unpack_value_array_2(ctx, v765);
                                                                                if v761.0 == v767.0 {
                                                                                    if v761.1 == v767.1 {
                                                                                        let v356 = constructor_iconst_u(ctx, v353, 0x0_u64);
                                                                                        // Rule at src/opts/icmp.isle line 322.
                                                                                        returns.extend(Some(v356));
                                                                                        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 v1485 = constructor_intcc_comparable(ctx, v760, v766);
                                                                if let Some(v1486) = v1485 {
                                                                    let v761 = C::unpack_value_array_2(ctx, v759);
                                                                    let v767 = C::unpack_value_array_2(ctx, v765);
                                                                    if v761.0 == v767.0 {
                                                                        if v761.1 == v767.1 {
                                                                            let v1487 = constructor_decompose_intcc(ctx, v760);
                                                                            let v1488 = constructor_decompose_intcc(ctx, v766);
                                                                            let v1489 = C::u64_and(ctx, v1487, v1488);
                                                                            let v1490 = constructor_compose_icmp(ctx, v335, v1489, v1486, v761.0, v761.1);
                                                                            // Rule at src/opts/icmp.isle line 179.
                                                                            returns.extend(Some(v1490));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v26,
                                    arg: v27,
                                } => {
                                    match v26 {
                                        &Opcode::Splat => {
                                            let v2006 = C::ty_vector_not_float(ctx, v2.0);
                                            if let Some(v2007) = v2006 {
                                                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 v1869 = C::lane_type(ctx, v2.0);
                                                                    let v2008 = constructor_band(ctx, v1869, v30, v27);
                                                                    let v2009 = constructor_splat(ctx, v2.0, v2008);
                                                                    // Rule at src/opts/vector.isle line 14.
                                                                    returns.extend(Some(v2009));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Bnot => {
                                            if v2.0 == v11.0 {
                                                let mut v648 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v27, &mut v648);
                                                let mut v648 = v648.into_context_iter();
                                                while let Some(v649) = v648.next(ctx) {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v652,
                                                        args: ref v653,
                                                    } = &v649.1 {
                                                        match v652 {
                                                            &Opcode::Band => {
                                                                if v2.0 == v649.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 v654 = C::unpack_value_array_2(ctx, v653);
                                                                                                    if v99.1 == v654.0 {
                                                                                                        if v107 == v654.1 {
                                                                                                            let v934 = constructor_bnot(ctx, v2.0, v107);
                                                                                                            // Rule at src/opts/bitops.isle line 671.
                                                                                                            returns.extend(Some(v934));
                                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                        }
                                                                                                    }
                                                                                                    if v107 == v654.0 {
                                                                                                        if v99.1 == v654.1 {
                                                                                                            let v934 = constructor_bnot(ctx, v2.0, v107);
                                                                                                            // Rule at src/opts/bitops.isle line 669.
                                                                                                            returns.extend(Some(v934));
                                                                                                            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 v654 = C::unpack_value_array_2(ctx, v653);
                                                                                                    if v99.0 == v654.0 {
                                                                                                        if v114 == v654.1 {
                                                                                                            let v935 = constructor_bnot(ctx, v2.0, v114);
                                                                                                            // Rule at src/opts/bitops.isle line 675.
                                                                                                            returns.extend(Some(v935));
                                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                        }
                                                                                                    }
                                                                                                    if v114 == v654.0 {
                                                                                                        if v99.0 == v654.1 {
                                                                                                            let v935 = constructor_bnot(ctx, v2.0, v114);
                                                                                                            // Rule at src/opts/bitops.isle line 673.
                                                                                                            returns.extend(Some(v935));
                                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    let v654 = C::unpack_value_array_2(ctx, v653);
                                                                    if v7.0 == v654.0 {
                                                                        let v745 = constructor_bnot(ctx, v2.0, v654.1);
                                                                        let v751 = constructor_band(ctx, v2.0, v7.0, v745);
                                                                        // Rule at src/opts/bitops.isle line 329.
                                                                        returns.extend(Some(v751));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v7.0 == v654.1 {
                                                                        let v741 = constructor_bnot(ctx, v2.0, v654.0);
                                                                        let v749 = constructor_band(ctx, v2.0, v7.0, v741);
                                                                        // Rule at src/opts/bitops.isle line 327.
                                                                        returns.extend(Some(v749));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Bxor => {
                                                                if v2.0 == v649.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 v654 = C::unpack_value_array_2(ctx, v653);
                                                                                    if v99.0 == v654.0 {
                                                                                        if v99.1 == v654.1 {
                                                                                            let v138 = constructor_band(ctx, v2.0, v99.0, v99.1);
                                                                                            // Rule at src/opts/bitops.isle line 588.
                                                                                            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 594.
                                                                                            returns.extend(Some(v242));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                    if v99.0 == v654.1 {
                                                                                        if v99.1 == v654.0 {
                                                                                            let v138 = constructor_band(ctx, v2.0, v99.0, v99.1);
                                                                                            // Rule at src/opts/bitops.isle line 590.
                                                                                            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 592.
                                                                                            returns.extend(Some(v242));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    let v654 = C::unpack_value_array_2(ctx, v653);
                                                                    if v7.0 == v654.0 {
                                                                        let v897 = constructor_band(ctx, v2.0, v7.0, v654.1);
                                                                        // Rule at src/opts/bitops.isle line 610.
                                                                        returns.extend(Some(v897));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v7.0 == v654.1 {
                                                                        let v898 = constructor_band(ctx, v2.0, v7.0, v654.0);
                                                                        // Rule at src/opts/bitops.isle line 612.
                                                                        returns.extend(Some(v898));
                                                                        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 v709 = constructor_bor(ctx, v2.0, v30, v27);
                                                                let v710 = constructor_bnot(ctx, v2.0, v709);
                                                                // Rule at src/opts/bitops.isle line 293.
                                                                returns.extend(Some(v710));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                let v711 = constructor_bor(ctx, v2.0, v27, v30);
                                                                let v712 = constructor_bnot(ctx, v2.0, v711);
                                                                // Rule at src/opts/bitops.isle line 294.
                                                                returns.extend(Some(v712));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            let v352 = C::ty_int_vec128(ctx, v2.0);
                                            if let Some(v353) = v352 {
                                                if v11.0 == v353 {
                                                    if v7.0 == v27 {
                                                        let v356 = constructor_iconst_u(ctx, v353, 0x0_u64);
                                                        let v357 = C::subsume(ctx, v356);
                                                        // Rule at src/opts/bitops.isle line 42.
                                                        returns.extend(Some(v357));
                                                        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 v1364 = C::value_type(ctx, v30);
                                                        let v1395 = C::value_type(ctx, v27);
                                                        if v1364 == v1395 {
                                                            let v1396 = constructor_band(ctx, v1364, v30, v27);
                                                            let v1397 = constructor_uextend(ctx, v2.0, v1396);
                                                            // Rule at src/opts/extends.isle line 70.
                                                            returns.extend(Some(v1397));
                                                            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 v1062 = constructor_band(ctx, v2.0, v99.1, v7.1);
                                                                                let v1063 = constructor_band(ctx, v2.0, v99.0, v1062);
                                                                                // Rule at src/opts/cprop.isle line 219.
                                                                                returns.extend(Some(v1063));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                &InstructionData::IntCompare {
                                                    opcode: ref v758,
                                                    args: ref v759,
                                                    cond: ref v760,
                                                } => {
                                                    if let &Opcode::Icmp = v758 {
                                                        let v16 = C::u64_from_imm64(ctx, v15);
                                                        if v16 == 0x1_u64 {
                                                            let v1386 = C::ty_int(ctx, v2.0);
                                                            if let Some(v1387) = v1386 {
                                                                // 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 v1386 = C::ty_int(ctx, v2.0);
                                                                if let Some(v1387) = v1386 {
                                                                    let mut v658 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v30, &mut v658);
                                                                    let mut v658 = v658.into_context_iter();
                                                                    while let Some(v659) = v658.next(ctx) {
                                                                        if let &InstructionData::IntCompare {
                                                                            opcode: ref v1465,
                                                                            args: ref v1466,
                                                                            cond: ref v1467,
                                                                        } = &v659.1 {
                                                                            if let &Opcode::Icmp = v1465 {
                                                                                // Rule at src/opts/icmp.isle line 95.
                                                                                returns.extend(Some(v7.0));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            let v1364 = C::value_type(ctx, v30);
                                                            let v1365 = C::ty_mask(ctx, v1364);
                                                            let v1366 = C::u64_and(ctx, v16, v1365);
                                                            let v1367 = C::u64_eq(ctx, v1365, v1366);
                                                            if v1367 == 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 v1364 = C::value_type(ctx, v30);
                                                            let v1365 = C::ty_mask(ctx, v1364);
                                                            let v1368 = C::u64_eq(ctx, v16, v1365);
                                                            if v1368 == true {
                                                                let v1369 = constructor_uextend(ctx, v2.0, v30);
                                                                // Rule at src/opts/extends.isle line 22.
                                                                returns.extend(Some(v1369));
                                                                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 v973 = C::imm64_and(ctx, v335, v23, v15);
                                                                    let v974 = constructor_iconst(ctx, v335, v973);
                                                                    let v975 = C::subsume(ctx, v974);
                                                                    // Rule at src/opts/cprop.isle line 61.
                                                                    returns.extend(Some(v975));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                _ => {}
                                            }
                                        }
                                        let v16 = C::u64_from_imm64(ctx, v15);
                                        if v16 == 0x0_u64 {
                                            let v352 = C::ty_int_vec128(ctx, v2.0);
                                            if let Some(v353) = v352 {
                                                if v11.0 == v353 {
                                                    let v55 = C::subsume(ctx, v7.1);
                                                    // Rule at src/opts/bitops.isle line 41.
                                                    returns.extend(Some(v55));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        let v1625 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 13.
                                        returns.extend(Some(v1625));
                                        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 200.
                                                    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 201.
                                                    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 v859 = constructor_bor(ctx, v2.0, v99.1, v286.1);
                                                                        let v860 = constructor_band(ctx, v2.0, v859, v286.0);
                                                                        // Rule at src/opts/bitops.isle line 516.
                                                                        returns.extend(Some(v860));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v7.1 == v286.1 {
                                                                        let v867 = constructor_bor(ctx, v2.0, v99.1, v286.0);
                                                                        let v868 = constructor_band(ctx, v2.0, v867, v286.1);
                                                                        // Rule at src/opts/bitops.isle line 520.
                                                                        returns.extend(Some(v868));
                                                                        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 v872 = constructor_band(ctx, v2.0, v107, v99.1);
                                                                        // Rule at src/opts/bitops.isle line 535.
                                                                        returns.extend(Some(v872));
                                                                        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 v855 = constructor_bor(ctx, v2.0, v99.0, v270.1);
                                                                        let v856 = constructor_band(ctx, v2.0, v855, v270.0);
                                                                        // Rule at src/opts/bitops.isle line 514.
                                                                        returns.extend(Some(v856));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v7.1 == v270.1 {
                                                                        let v863 = constructor_bor(ctx, v2.0, v99.0, v270.0);
                                                                        let v864 = constructor_band(ctx, v2.0, v863, v270.1);
                                                                        // Rule at src/opts/bitops.isle line 518.
                                                                        returns.extend(Some(v864));
                                                                        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 v874 = constructor_band(ctx, v2.0, v114, v99.0);
                                                                        // Rule at src/opts/bitops.isle line 537.
                                                                        returns.extend(Some(v874));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                if v7.1 == v99.0 {
                                                    // Rule at src/opts/bitops.isle line 257.
                                                    returns.extend(Some(v99.0));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.1 == v99.1 {
                                                    // Rule at src/opts/bitops.isle line 259.
                                                    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 v872 = constructor_band(ctx, v2.0, v107, v99.1);
                                                                    // Rule at src/opts/bitops.isle line 617.
                                                                    returns.extend(Some(v872));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v7.1 == v99.1 {
                                                                    let v635 = constructor_band(ctx, v2.0, v99.1, v107);
                                                                    // Rule at src/opts/bitops.isle line 207.
                                                                    returns.extend(Some(v635));
                                                                    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 v634 = constructor_band(ctx, v2.0, v99.0, v114);
                                                                    // Rule at src/opts/bitops.isle line 206.
                                                                    returns.extend(Some(v634));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v7.1 == v114 {
                                                                    let v874 = constructor_band(ctx, v2.0, v114, v99.0);
                                                                    // Rule at src/opts/bitops.isle line 619.
                                                                    returns.extend(Some(v874));
                                                                    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 v658 = C::inst_data_value_etor_returns::default();
                                            C::inst_data_value_etor(ctx, v30, &mut v658);
                                            let mut v658 = v658.into_context_iter();
                                            while let Some(v659) = v658.next(ctx) {
                                                if let &InstructionData::Binary {
                                                    opcode: ref v662,
                                                    args: ref v663,
                                                } = &v659.1 {
                                                    match v662 {
                                                        &Opcode::Band => {
                                                            if v2.0 == v659.0 {
                                                                let v664 = C::unpack_value_array_2(ctx, v663);
                                                                if v7.1 == v664.0 {
                                                                    let v747 = constructor_bnot(ctx, v2.0, v664.1);
                                                                    let v752 = constructor_band(ctx, v2.0, v664.0, v747);
                                                                    // Rule at src/opts/bitops.isle line 330.
                                                                    returns.extend(Some(v752));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v7.1 == v664.1 {
                                                                    let v743 = constructor_bnot(ctx, v2.0, v664.0);
                                                                    let v750 = constructor_band(ctx, v2.0, v664.1, v743);
                                                                    // Rule at src/opts/bitops.isle line 328.
                                                                    returns.extend(Some(v750));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                        &Opcode::Bxor => {
                                                            if v2.0 == v659.0 {
                                                                let v664 = C::unpack_value_array_2(ctx, v663);
                                                                if v7.1 == v664.0 {
                                                                    let v891 = constructor_band(ctx, v2.0, v664.0, v664.1);
                                                                    // Rule at src/opts/bitops.isle line 611.
                                                                    returns.extend(Some(v891));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v7.1 == v664.1 {
                                                                    let v892 = constructor_band(ctx, v2.0, v664.1, v664.0);
                                                                    // Rule at src/opts/bitops.isle line 613.
                                                                    returns.extend(Some(v892));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                            }
                                        }
                                        if v7.1 == v30 {
                                            let v352 = C::ty_int_vec128(ctx, v2.0);
                                            if let Some(v353) = v352 {
                                                if v19.0 == v353 {
                                                    let v356 = constructor_iconst_u(ctx, v353, 0x0_u64);
                                                    let v357 = C::subsume(ctx, v356);
                                                    // Rule at src/opts/bitops.isle line 43.
                                                    returns.extend(Some(v357));
                                                    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 v1033 = constructor_band(ctx, v2.0, v7.1, v7.0);
                                            // Rule at src/opts/cprop.isle line 161.
                                            returns.extend(Some(v1033));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        let v1625 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 11.
                                        returns.extend(Some(v1625));
                                        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 36.
                            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 37.
                                        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 v636,
                                                                                                    arg: v637,
                                                                                                } = &v259.1 {
                                                                                                    if let &Opcode::Bnot = v636 {
                                                                                                        if v2.0 == v259.0 {
                                                                                                            if v99.1 == v637 {
                                                                                                                let v883 = constructor_bxor(ctx, v2.0, v107, v99.1);
                                                                                                                // Rule at src/opts/bitops.isle line 557.
                                                                                                                returns.extend(Some(v883));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                let v879 = constructor_bxor(ctx, v2.0, v99.1, v107);
                                                                                                                // Rule at src/opts/bitops.isle line 562.
                                                                                                                returns.extend(Some(v879));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                            if v99.1 == v135.1 {
                                                                                                // Rule at src/opts/bitops.isle line 479.
                                                                                                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 v639,
                                                                                                    arg: v640,
                                                                                                } = &v275.1 {
                                                                                                    if let &Opcode::Bnot = v639 {
                                                                                                        if v2.0 == v275.0 {
                                                                                                            if v99.1 == v640 {
                                                                                                                let v879 = constructor_bxor(ctx, v2.0, v99.1, v107);
                                                                                                                // Rule at src/opts/bitops.isle line 560.
                                                                                                                returns.extend(Some(v879));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                let v883 = constructor_bxor(ctx, v2.0, v107, v99.1);
                                                                                                                // Rule at src/opts/bitops.isle line 561.
                                                                                                                returns.extend(Some(v883));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                            if v99.1 == v135.0 {
                                                                                                // Rule at src/opts/bitops.isle line 475.
                                                                                                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 v636,
                                                                                                    arg: v637,
                                                                                                } = &v259.1 {
                                                                                                    if let &Opcode::Bnot = v636 {
                                                                                                        if v99.0 == v637 {
                                                                                                            if v2.0 == v259.0 {
                                                                                                                let v877 = constructor_bxor(ctx, v2.0, v99.0, v114);
                                                                                                                // Rule at src/opts/bitops.isle line 558.
                                                                                                                returns.extend(Some(v877));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                let v884 = constructor_bxor(ctx, v2.0, v114, v99.0);
                                                                                                                // Rule at src/opts/bitops.isle line 559.
                                                                                                                returns.extend(Some(v884));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                            if v99.0 == v135.1 {
                                                                                                // Rule at src/opts/bitops.isle line 477.
                                                                                                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 v639,
                                                                                                    arg: v640,
                                                                                                } = &v275.1 {
                                                                                                    if let &Opcode::Bnot = v639 {
                                                                                                        if v99.0 == v640 {
                                                                                                            if v2.0 == v275.0 {
                                                                                                                let v877 = constructor_bxor(ctx, v2.0, v99.0, v114);
                                                                                                                // Rule at src/opts/bitops.isle line 556.
                                                                                                                returns.extend(Some(v877));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                let v884 = constructor_bxor(ctx, v2.0, v114, v99.0);
                                                                                                                // Rule at src/opts/bitops.isle line 563.
                                                                                                                returns.extend(Some(v884));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                            if v99.0 == v135.0 {
                                                                                                // Rule at src/opts/bitops.isle line 473.
                                                                                                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 v636,
                                                                                    arg: v637,
                                                                                } = &v259.1 {
                                                                                    if let &Opcode::Bnot = v636 {
                                                                                        if v99.1 == v637 {
                                                                                            if v2.0 == v259.0 {
                                                                                                // Rule at src/opts/bitops.isle line 472.
                                                                                                returns.extend(Some(v99.0));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            let v705 = constructor_bor(ctx, v2.0, v99.1, v135.1);
                                                                            let v706 = constructor_band(ctx, v2.0, v705, v99.0);
                                                                            // Rule at src/opts/bitops.isle line 279.
                                                                            returns.extend(Some(v706));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            let v707 = constructor_bor(ctx, v2.0, v135.1, v99.1);
                                                                            let v708 = constructor_band(ctx, v2.0, v707, v99.0);
                                                                            // Rule at src/opts/bitops.isle line 280.
                                                                            returns.extend(Some(v708));
                                                                            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 v636,
                                                                                    arg: v637,
                                                                                } = &v259.1 {
                                                                                    if let &Opcode::Bnot = v636 {
                                                                                        if v99.0 == v637 {
                                                                                            if v2.0 == v259.0 {
                                                                                                // Rule at src/opts/bitops.isle line 476.
                                                                                                returns.extend(Some(v99.1));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            let v697 = constructor_bor(ctx, v2.0, v99.0, v135.1);
                                                                            let v698 = constructor_band(ctx, v2.0, v697, v99.1);
                                                                            // Rule at src/opts/bitops.isle line 275.
                                                                            returns.extend(Some(v698));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            let v703 = constructor_bor(ctx, v2.0, v135.1, v99.0);
                                                                            let v704 = constructor_band(ctx, v2.0, v703, v99.1);
                                                                            // Rule at src/opts/bitops.isle line 278.
                                                                            returns.extend(Some(v704));
                                                                            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 v639,
                                                                                    arg: v640,
                                                                                } = &v275.1 {
                                                                                    if let &Opcode::Bnot = v639 {
                                                                                        if v99.1 == v640 {
                                                                                            if v2.0 == v275.0 {
                                                                                                // Rule at src/opts/bitops.isle line 474.
                                                                                                returns.extend(Some(v99.0));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            let v699 = constructor_bor(ctx, v2.0, v135.0, v99.1);
                                                                            let v700 = constructor_band(ctx, v2.0, v699, v99.0);
                                                                            // Rule at src/opts/bitops.isle line 276.
                                                                            returns.extend(Some(v700));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            let v701 = constructor_bor(ctx, v2.0, v99.1, v135.0);
                                                                            let v702 = constructor_band(ctx, v2.0, v701, v99.0);
                                                                            // Rule at src/opts/bitops.isle line 277.
                                                                            returns.extend(Some(v702));
                                                                            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 v639,
                                                                                    arg: v640,
                                                                                } = &v275.1 {
                                                                                    if let &Opcode::Bnot = v639 {
                                                                                        if v99.0 == v640 {
                                                                                            if v2.0 == v275.0 {
                                                                                                // Rule at src/opts/bitops.isle line 478.
                                                                                                returns.extend(Some(v99.1));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            let v693 = constructor_bor(ctx, v2.0, v99.0, v135.0);
                                                                            let v694 = constructor_band(ctx, v2.0, v693, v99.1);
                                                                            // Rule at src/opts/bitops.isle line 273.
                                                                            returns.extend(Some(v694));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            let v695 = constructor_bor(ctx, v2.0, v135.0, v99.0);
                                                                            let v696 = constructor_band(ctx, v2.0, v695, v99.1);
                                                                            // Rule at src/opts/bitops.isle line 274.
                                                                            returns.extend(Some(v696));
                                                                            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 v636,
                                                                                arg: v637,
                                                                            } = &v259.1 {
                                                                                if let &Opcode::Bnot = v636 {
                                                                                    if v2.0 == v259.0 {
                                                                                        let v99 = C::unpack_value_array_2(ctx, v98);
                                                                                        if v99.0 == v135.0 {
                                                                                            if v99.1 == v637 {
                                                                                                let v238 = constructor_bxor(ctx, v2.0, v99.0, v99.1);
                                                                                                // Rule at src/opts/bitops.isle line 567.
                                                                                                returns.extend(Some(v238));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                        if v99.0 == v637 {
                                                                                            if v99.1 == v135.0 {
                                                                                                let v239 = constructor_bxor(ctx, v2.0, v99.1, v99.0);
                                                                                                // Rule at src/opts/bitops.isle line 569.
                                                                                                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 v639,
                                                                                arg: v640,
                                                                            } = &v275.1 {
                                                                                if let &Opcode::Bnot = v639 {
                                                                                    if v2.0 == v275.0 {
                                                                                        let v99 = C::unpack_value_array_2(ctx, v98);
                                                                                        if v99.0 == v135.1 {
                                                                                            if v99.1 == v640 {
                                                                                                let v238 = constructor_bxor(ctx, v2.0, v99.0, v99.1);
                                                                                                // Rule at src/opts/bitops.isle line 571.
                                                                                                returns.extend(Some(v238));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                        if v99.0 == v640 {
                                                                                            if v99.1 == v135.1 {
                                                                                                let v239 = constructor_bxor(ctx, v2.0, v99.1, v99.0);
                                                                                                // Rule at src/opts/bitops.isle line 573.
                                                                                                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 v658 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v30, &mut v658);
                                                                    let mut v658 = v658.into_context_iter();
                                                                    while let Some(v659) = v658.next(ctx) {
                                                                        if let &InstructionData::Binary {
                                                                            opcode: ref v662,
                                                                            args: ref v663,
                                                                        } = &v659.1 {
                                                                            match v662 {
                                                                                &Opcode::Bor => {
                                                                                    if v2.0 == v659.0 {
                                                                                        let v135 = C::unpack_value_array_2(ctx, v134);
                                                                                        let v664 = C::unpack_value_array_2(ctx, v663);
                                                                                        if v135.0 == v664.0 {
                                                                                            if v135.1 == v664.1 {
                                                                                                let v667 = constructor_bxor(ctx, v2.0, v664.0, v664.1);
                                                                                                let v668 = constructor_bnot(ctx, v2.0, v667);
                                                                                                // Rule at src/opts/bitops.isle line 680.
                                                                                                returns.extend(Some(v668));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v669 = constructor_bxor(ctx, v2.0, v664.1, v664.0);
                                                                                                let v670 = constructor_bnot(ctx, v2.0, v669);
                                                                                                // Rule at src/opts/bitops.isle line 686.
                                                                                                returns.extend(Some(v670));
                                                                                                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 v636,
                                                                                                    arg: v637,
                                                                                                } = &v259.1 {
                                                                                                    if let &Opcode::Bnot = v636 {
                                                                                                        if v637 == v664.1 {
                                                                                                            if v2.0 == v259.0 {
                                                                                                                let v747 = constructor_bnot(ctx, v2.0, v664.1);
                                                                                                                // Rule at src/opts/bitops.isle line 666.
                                                                                                                returns.extend(Some(v747));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                        if v135.0 == v664.1 {
                                                                                            if v135.1 == v664.0 {
                                                                                                let v669 = constructor_bxor(ctx, v2.0, v664.1, v664.0);
                                                                                                let v670 = constructor_bnot(ctx, v2.0, v669);
                                                                                                // Rule at src/opts/bitops.isle line 682.
                                                                                                returns.extend(Some(v670));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v667 = constructor_bxor(ctx, v2.0, v664.0, v664.1);
                                                                                                let v668 = constructor_bnot(ctx, v2.0, v667);
                                                                                                // Rule at src/opts/bitops.isle line 684.
                                                                                                returns.extend(Some(v668));
                                                                                                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 v636,
                                                                                                    arg: v637,
                                                                                                } = &v259.1 {
                                                                                                    if let &Opcode::Bnot = v636 {
                                                                                                        if v637 == v664.0 {
                                                                                                            if v2.0 == v259.0 {
                                                                                                                let v743 = constructor_bnot(ctx, v2.0, v664.0);
                                                                                                                // Rule at src/opts/bitops.isle line 664.
                                                                                                                returns.extend(Some(v743));
                                                                                                                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 v639,
                                                                                                arg: v640,
                                                                                            } = &v275.1 {
                                                                                                if let &Opcode::Bnot = v639 {
                                                                                                    if v2.0 == v275.0 {
                                                                                                        if v640 == v664.0 {
                                                                                                            if v135.1 == v664.1 {
                                                                                                                let v743 = constructor_bnot(ctx, v2.0, v664.0);
                                                                                                                // Rule at src/opts/bitops.isle line 660.
                                                                                                                returns.extend(Some(v743));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                        if v640 == v664.1 {
                                                                                                            if v135.1 == v664.0 {
                                                                                                                let v747 = constructor_bnot(ctx, v2.0, v664.1);
                                                                                                                // Rule at src/opts/bitops.isle line 662.
                                                                                                                returns.extend(Some(v747));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                                &Opcode::Bxor => {
                                                                                    if v2.0 == v659.0 {
                                                                                        let v135 = C::unpack_value_array_2(ctx, v134);
                                                                                        let v664 = C::unpack_value_array_2(ctx, v663);
                                                                                        if v135.0 == v664.0 {
                                                                                            if v135.1 == v664.1 {
                                                                                                let v667 = constructor_bxor(ctx, v2.0, v664.0, v664.1);
                                                                                                let v668 = constructor_bnot(ctx, v2.0, v667);
                                                                                                // Rule at src/opts/bitops.isle line 238.
                                                                                                returns.extend(Some(v668));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v669 = constructor_bxor(ctx, v2.0, v664.1, v664.0);
                                                                                                let v670 = constructor_bnot(ctx, v2.0, v669);
                                                                                                // Rule at src/opts/bitops.isle line 244.
                                                                                                returns.extend(Some(v670));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                        if v135.0 == v664.1 {
                                                                                            if v135.1 == v664.0 {
                                                                                                let v669 = constructor_bxor(ctx, v2.0, v664.1, v664.0);
                                                                                                let v670 = constructor_bnot(ctx, v2.0, v669);
                                                                                                // Rule at src/opts/bitops.isle line 240.
                                                                                                returns.extend(Some(v670));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v667 = constructor_bxor(ctx, v2.0, v664.0, v664.1);
                                                                                                let v668 = constructor_bnot(ctx, v2.0, v667);
                                                                                                // Rule at src/opts/bitops.isle line 242.
                                                                                                returns.extend(Some(v668));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                                _ => {}
                                                                            }
                                                                        }
                                                                    }
                                                                    let v135 = C::unpack_value_array_2(ctx, v134);
                                                                    if v30 == v135.0 {
                                                                        let v644 = constructor_bnot(ctx, v2.0, v30);
                                                                        let v645 = constructor_bor(ctx, v2.0, v135.1, v644);
                                                                        // Rule at src/opts/bitops.isle line 229.
                                                                        returns.extend(Some(v645));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v30 == v135.1 {
                                                                        let v359 = constructor_bor(ctx, v2.0, v135.0, v7.0);
                                                                        // Rule at src/opts/bitops.isle line 61.
                                                                        returns.extend(Some(v359));
                                                                        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 v841 = constructor_band(ctx, v2.0, v135.0, v264.1);
                                                                            let v842 = constructor_bor(ctx, v2.0, v841, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 505.
                                                                            returns.extend(Some(v842));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.0 == v264.1 {
                                                                            let v849 = constructor_band(ctx, v2.0, v135.0, v264.0);
                                                                            let v850 = constructor_bor(ctx, v2.0, v849, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 509.
                                                                            returns.extend(Some(v850));
                                                                            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 v819 = constructor_band(ctx, v2.0, v264.1, v135.0);
                                                                            let v820 = constructor_bor(ctx, v2.0, v819, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 449.
                                                                            returns.extend(Some(v820));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.0 == v264.1 {
                                                                            let v811 = constructor_band(ctx, v2.0, v264.0, v135.0);
                                                                            let v812 = constructor_bor(ctx, v2.0, v811, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 445.
                                                                            returns.extend(Some(v812));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v636,
                                                            arg: v637,
                                                        } => {
                                                            if let &Opcode::Bnot = v636 {
                                                                if v7.0 == v637 {
                                                                    if v2.0 == v259.0 {
                                                                        let v794 = constructor_bor(ctx, v2.0, v7.0, v135.0);
                                                                        // Rule at src/opts/bitops.isle line 542.
                                                                        returns.extend(Some(v794));
                                                                        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 v845 = constructor_band(ctx, v2.0, v135.1, v280.1);
                                                                            let v846 = constructor_bor(ctx, v2.0, v845, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 507.
                                                                            returns.extend(Some(v846));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.0 == v280.1 {
                                                                            let v853 = constructor_band(ctx, v2.0, v135.1, v280.0);
                                                                            let v854 = constructor_bor(ctx, v2.0, v853, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 511.
                                                                            returns.extend(Some(v854));
                                                                            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 v815 = constructor_band(ctx, v2.0, v280.1, v135.1);
                                                                            let v816 = constructor_bor(ctx, v2.0, v815, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 447.
                                                                            returns.extend(Some(v816));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.0 == v280.1 {
                                                                            let v807 = constructor_band(ctx, v2.0, v280.0, v135.1);
                                                                            let v808 = constructor_bor(ctx, v2.0, v807, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 443.
                                                                            returns.extend(Some(v808));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v639,
                                                            arg: v640,
                                                        } => {
                                                            if let &Opcode::Bnot = v639 {
                                                                if v7.0 == v640 {
                                                                    if v2.0 == v275.0 {
                                                                        let v631 = constructor_bor(ctx, v2.0, v7.0, v135.1);
                                                                        // Rule at src/opts/bitops.isle line 540.
                                                                        returns.extend(Some(v631));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                if v7.0 == v135.0 {
                                                    // Rule at src/opts/bitops.isle line 221.
                                                    returns.extend(Some(v7.0));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                            let v1099 = C::ty_vec128(ctx, v2.0);
                                            if let Some(v1100) = v1099 {
                                                if v11.0 == v1100 {
                                                    let mut v18 = C::inst_data_value_etor_returns::default();
                                                    C::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 v1669 = constructor_bitselect(ctx, v1100, v107, v135.1, v99.1);
                                                                                        // Rule at src/opts/selects.isle line 73.
                                                                                        returns.extend(Some(v1669));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v107 == v135.1 {
                                                                                        let v1670 = constructor_bitselect(ctx, v1100, v107, v135.0, v99.1);
                                                                                        // Rule at src/opts/selects.isle line 74.
                                                                                        returns.extend(Some(v1670));
                                                                                        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 v1671 = constructor_bitselect(ctx, v1100, v114, v135.1, v99.0);
                                                                                        // Rule at src/opts/selects.isle line 75.
                                                                                        returns.extend(Some(v1671));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v114 == v135.1 {
                                                                                        let v1672 = constructor_bitselect(ctx, v1100, v114, v135.0, v99.0);
                                                                                        // Rule at src/opts/selects.isle line 76.
                                                                                        returns.extend(Some(v1672));
                                                                                        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 v636,
                                                                            arg: v637,
                                                                        } = &v259.1 {
                                                                            if let &Opcode::Bnot = v636 {
                                                                                if v11.0 == v259.0 {
                                                                                    if v99.0 == v637 {
                                                                                        let v1666 = constructor_bitselect(ctx, v1100, v99.0, v99.1, v135.0);
                                                                                        // Rule at src/opts/selects.isle line 70.
                                                                                        returns.extend(Some(v1666));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v99.1 == v637 {
                                                                                        let v1668 = constructor_bitselect(ctx, v1100, v99.1, v99.0, v135.0);
                                                                                        // Rule at src/opts/selects.isle line 72.
                                                                                        returns.extend(Some(v1668));
                                                                                        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 v639,
                                                                            arg: v640,
                                                                        } = &v275.1 {
                                                                            if let &Opcode::Bnot = v639 {
                                                                                if v11.0 == v275.0 {
                                                                                    if v99.0 == v640 {
                                                                                        let v1665 = constructor_bitselect(ctx, v1100, v99.0, v99.1, v135.1);
                                                                                        // Rule at src/opts/selects.isle line 69.
                                                                                        returns.extend(Some(v1665));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v99.1 == v640 {
                                                                                        let v1667 = constructor_bitselect(ctx, v1100, v99.1, v99.0, v135.1);
                                                                                        // Rule at src/opts/selects.isle line 71.
                                                                                        returns.extend(Some(v1667));
                                                                                        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 v1148,
                                                                                        imm: v1149,
                                                                                    } = &v259.1 {
                                                                                        if let &Opcode::Iconst = v1148 {
                                                                                            let v693 = constructor_bor(ctx, v2.0, v99.0, v135.0);
                                                                                            let v1157 = constructor_bor(ctx, v2.0, v99.1, v135.1);
                                                                                            let v1158 = constructor_bor(ctx, v2.0, v693, v1157);
                                                                                            // Rule at src/opts/cprop.isle line 344.
                                                                                            returns.extend(Some(v1158));
                                                                                            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 623.
                                                                            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 629.
                                                                            returns.extend(Some(v241));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        let v703 = constructor_bor(ctx, v2.0, v135.1, v99.0);
                                                                        let v799 = constructor_bor(ctx, v2.0, v703, v99.1);
                                                                        // Rule at src/opts/bitops.isle line 424.
                                                                        returns.extend(Some(v799));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        let v697 = constructor_bor(ctx, v2.0, v99.0, v135.1);
                                                                        let v821 = constructor_bor(ctx, v2.0, v697, v99.1);
                                                                        // Rule at src/opts/bitops.isle line 453.
                                                                        returns.extend(Some(v821));
                                                                        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 625.
                                                                            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 627.
                                                                            returns.extend(Some(v240));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        let v695 = constructor_bor(ctx, v2.0, v135.0, v99.0);
                                                                        let v797 = constructor_bor(ctx, v2.0, v695, v99.1);
                                                                        // Rule at src/opts/bitops.isle line 422.
                                                                        returns.extend(Some(v797));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        let v693 = constructor_bor(ctx, v2.0, v99.0, v135.0);
                                                                        let v823 = constructor_bor(ctx, v2.0, v693, v99.1);
                                                                        // Rule at src/opts/bitops.isle line 457.
                                                                        returns.extend(Some(v823));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v99.1 == v135.0 {
                                                                        let v707 = constructor_bor(ctx, v2.0, v135.1, v99.1);
                                                                        let v803 = constructor_bor(ctx, v2.0, v707, v99.0);
                                                                        // Rule at src/opts/bitops.isle line 428.
                                                                        returns.extend(Some(v803));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        let v705 = constructor_bor(ctx, v2.0, v99.1, v135.1);
                                                                        let v822 = constructor_bor(ctx, v2.0, v705, v99.0);
                                                                        // Rule at src/opts/bitops.isle line 455.
                                                                        returns.extend(Some(v822));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v99.1 == v135.1 {
                                                                        let v699 = constructor_bor(ctx, v2.0, v135.0, v99.1);
                                                                        let v801 = constructor_bor(ctx, v2.0, v699, v99.0);
                                                                        // Rule at src/opts/bitops.isle line 426.
                                                                        returns.extend(Some(v801));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        let v701 = constructor_bor(ctx, v2.0, v99.1, v135.0);
                                                                        let v824 = constructor_bor(ctx, v2.0, v701, v99.0);
                                                                        // Rule at src/opts/bitops.isle line 459.
                                                                        returns.extend(Some(v824));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                    }
                                                }
                                                let v135 = C::unpack_value_array_2(ctx, v134);
                                                if v7.0 == v135.0 {
                                                    let v631 = constructor_bor(ctx, v2.0, v7.0, v135.1);
                                                    // Rule at src/opts/bitops.isle line 197.
                                                    returns.extend(Some(v631));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.0 == v135.1 {
                                                    let v359 = constructor_bor(ctx, v2.0, v135.0, v7.0);
                                                    // Rule at src/opts/bitops.isle line 198.
                                                    returns.extend(Some(v359));
                                                    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 v393 = C::inst_data_value_etor_returns::default();
                                                                                                                                            C::inst_data_value_etor(ctx, v286.1, &mut v393);
                                                                                                                                            let mut v393 = v393.into_context_iter();
                                                                                                                                            while let Some(v394) = v393.next(ctx) {
                                                                                                                                                if v394.0 == I32 {
                                                                                                                                                    if let &InstructionData::UnaryImm {
                                                                                                                                                        opcode: ref v397,
                                                                                                                                                        imm: v398,
                                                                                                                                                    } = &v394.1 {
                                                                                                                                                        if let &Opcode::Iconst = v397 {
                                                                                                                                                            let v399 = C::u64_from_imm64(ctx, v398);
                                                                                                                                                            if v399 == 0x18_u64 {
                                                                                                                                                                let v270 = C::unpack_value_array_2(ctx, v269);
                                                                                                                                                                let mut v400 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                C::inst_data_value_etor(ctx, v270.0, &mut v400);
                                                                                                                                                                let mut v400 = v400.into_context_iter();
                                                                                                                                                                while let Some(v401) = v400.next(ctx) {
                                                                                                                                                                    if v401.0 == I32 {
                                                                                                                                                                        if let &InstructionData::Binary {
                                                                                                                                                                            opcode: ref v404,
                                                                                                                                                                            args: ref v405,
                                                                                                                                                                        } = &v401.1 {
                                                                                                                                                                            if let &Opcode::Band = v404 {
                                                                                                                                                                                let v406 = C::unpack_value_array_2(ctx, v405);
                                                                                                                                                                                if v264.0 == v406.0 {
                                                                                                                                                                                    let mut v409 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                    C::inst_data_value_etor(ctx, v406.1, &mut v409);
                                                                                                                                                                                    let mut v409 = v409.into_context_iter();
                                                                                                                                                                                    while let Some(v410) = v409.next(ctx) {
                                                                                                                                                                                        if v410.0 == I32 {
                                                                                                                                                                                            if let &InstructionData::UnaryImm {
                                                                                                                                                                                                opcode: ref v413,
                                                                                                                                                                                                imm: v414,
                                                                                                                                                                                            } = &v410.1 {
                                                                                                                                                                                                if let &Opcode::Iconst = v413 {
                                                                                                                                                                                                    let v415 = C::u64_from_imm64(ctx, v414);
                                                                                                                                                                                                    if v415 == 0xff00_u64 {
                                                                                                                                                                                                        let mut v416 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                        C::inst_data_value_etor(ctx, v270.1, &mut v416);
                                                                                                                                                                                                        let mut v416 = v416.into_context_iter();
                                                                                                                                                                                                        while let Some(v417) = v416.next(ctx) {
                                                                                                                                                                                                            if v417.0 == I32 {
                                                                                                                                                                                                                if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                    opcode: ref v420,
                                                                                                                                                                                                                    imm: v421,
                                                                                                                                                                                                                } = &v417.1 {
                                                                                                                                                                                                                    if let &Opcode::Iconst = v420 {
                                                                                                                                                                                                                        let v422 = C::u64_from_imm64(ctx, v421);
                                                                                                                                                                                                                        if v422 == 0x8_u64 {
                                                                                                                                                                                                                            let v280 = C::unpack_value_array_2(ctx, v279);
                                                                                                                                                                                                                            let mut v423 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                            C::inst_data_value_etor(ctx, v280.0, &mut v423);
                                                                                                                                                                                                                            let mut v423 = v423.into_context_iter();
                                                                                                                                                                                                                            while let Some(v424) = v423.next(ctx) {
                                                                                                                                                                                                                                if v424.0 == I32 {
                                                                                                                                                                                                                                    if let &InstructionData::Binary {
                                                                                                                                                                                                                                        opcode: ref v427,
                                                                                                                                                                                                                                        args: ref v428,
                                                                                                                                                                                                                                    } = &v424.1 {
                                                                                                                                                                                                                                        if let &Opcode::Ushr = v427 {
                                                                                                                                                                                                                                            let v429 = C::unpack_value_array_2(ctx, v428);
                                                                                                                                                                                                                                            if v264.0 == v429.0 {
                                                                                                                                                                                                                                                let mut v432 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                C::inst_data_value_etor(ctx, v429.1, &mut v432);
                                                                                                                                                                                                                                                let mut v432 = v432.into_context_iter();
                                                                                                                                                                                                                                                while let Some(v433) = v432.next(ctx) {
                                                                                                                                                                                                                                                    if v433.0 == I32 {
                                                                                                                                                                                                                                                        if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                            opcode: ref v436,
                                                                                                                                                                                                                                                            imm: v437,
                                                                                                                                                                                                                                                        } = &v433.1 {
                                                                                                                                                                                                                                                            if let &Opcode::Iconst = v436 {
                                                                                                                                                                                                                                                                let v438 = C::u64_from_imm64(ctx, v437);
                                                                                                                                                                                                                                                                if v438 == 0x8_u64 {
                                                                                                                                                                                                                                                                    let mut v439 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                    C::inst_data_value_etor(ctx, v280.1, &mut v439);
                                                                                                                                                                                                                                                                    let mut v439 = v439.into_context_iter();
                                                                                                                                                                                                                                                                    while let Some(v440) = v439.next(ctx) {
                                                                                                                                                                                                                                                                        if v440.0 == I32 {
                                                                                                                                                                                                                                                                            if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                opcode: ref v443,
                                                                                                                                                                                                                                                                                imm: v444,
                                                                                                                                                                                                                                                                            } = &v440.1 {
                                                                                                                                                                                                                                                                                if let &Opcode::Iconst = v443 {
                                                                                                                                                                                                                                                                                    let v445 = C::u64_from_imm64(ctx, v444);
                                                                                                                                                                                                                                                                                    if v445 == 0xff00_u64 {
                                                                                                                                                                                                                                                                                        let mut v446 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                        C::inst_data_value_etor(ctx, v264.1, &mut v446);
                                                                                                                                                                                                                                                                                        let mut v446 = v446.into_context_iter();
                                                                                                                                                                                                                                                                                        while let Some(v447) = v446.next(ctx) {
                                                                                                                                                                                                                                                                                            if v447.0 == I32 {
                                                                                                                                                                                                                                                                                                if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                    opcode: ref v450,
                                                                                                                                                                                                                                                                                                    imm: v451,
                                                                                                                                                                                                                                                                                                } = &v447.1 {
                                                                                                                                                                                                                                                                                                    if let &Opcode::Iconst = v450 {
                                                                                                                                                                                                                                                                                                        let v452 = C::u64_from_imm64(ctx, v451);
                                                                                                                                                                                                                                                                                                        if v452 == 0x18_u64 {
                                                                                                                                                                                                                                                                                                            let v453 = constructor_bswap(ctx, v2.0, v286.0);
                                                                                                                                                                                                                                                                                                            // Rule at src/opts/bitops.isle line 150.
                                                                                                                                                                                                                                                                                                            returns.extend(Some(v453));
                                                                                                                                                                                                                                                                                                            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 v393 = C::inst_data_value_etor_returns::default();
                                                                                                                                        C::inst_data_value_etor(ctx, v286.1, &mut v393);
                                                                                                                                        let mut v393 = v393.into_context_iter();
                                                                                                                                        while let Some(v394) = v393.next(ctx) {
                                                                                                                                            if v394.0 == I64 {
                                                                                                                                                if let &InstructionData::Binary {
                                                                                                                                                    opcode: ref v470,
                                                                                                                                                    args: ref v471,
                                                                                                                                                } = &v394.1 {
                                                                                                                                                    if let &Opcode::Ishl = v470 {
                                                                                                                                                        let v270 = C::unpack_value_array_2(ctx, v269);
                                                                                                                                                        let mut v400 = C::inst_data_value_etor_returns::default();
                                                                                                                                                        C::inst_data_value_etor(ctx, v270.0, &mut v400);
                                                                                                                                                        let mut v400 = v400.into_context_iter();
                                                                                                                                                        while let Some(v401) = v400.next(ctx) {
                                                                                                                                                            if v401.0 == I64 {
                                                                                                                                                                if let &InstructionData::Binary {
                                                                                                                                                                    opcode: ref v404,
                                                                                                                                                                    args: ref v405,
                                                                                                                                                                } = &v401.1 {
                                                                                                                                                                    if let &Opcode::Ishl = v404 {
                                                                                                                                                                        let v406 = C::unpack_value_array_2(ctx, v405);
                                                                                                                                                                        let mut v409 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                        C::inst_data_value_etor(ctx, v406.1, &mut v409);
                                                                                                                                                                        let mut v409 = v409.into_context_iter();
                                                                                                                                                                        while let Some(v410) = v409.next(ctx) {
                                                                                                                                                                            if v410.0 == I64 {
                                                                                                                                                                                if let &InstructionData::UnaryImm {
                                                                                                                                                                                    opcode: ref v413,
                                                                                                                                                                                    imm: v414,
                                                                                                                                                                                } = &v410.1 {
                                                                                                                                                                                    if let &Opcode::Iconst = v413 {
                                                                                                                                                                                        let v415 = C::u64_from_imm64(ctx, v414);
                                                                                                                                                                                        if v415 == 0x18_u64 {
                                                                                                                                                                                            let mut v416 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                            C::inst_data_value_etor(ctx, v270.1, &mut v416);
                                                                                                                                                                                            let mut v416 = v416.into_context_iter();
                                                                                                                                                                                            while let Some(v417) = v416.next(ctx) {
                                                                                                                                                                                                if v417.0 == I64 {
                                                                                                                                                                                                    if let &InstructionData::Binary {
                                                                                                                                                                                                        opcode: ref v514,
                                                                                                                                                                                                        args: ref v515,
                                                                                                                                                                                                    } = &v417.1 {
                                                                                                                                                                                                        if let &Opcode::Ishl = v514 {
                                                                                                                                                                                                            let v280 = C::unpack_value_array_2(ctx, v279);
                                                                                                                                                                                                            let mut v423 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                            C::inst_data_value_etor(ctx, v280.0, &mut v423);
                                                                                                                                                                                                            let mut v423 = v423.into_context_iter();
                                                                                                                                                                                                            while let Some(v424) = v423.next(ctx) {
                                                                                                                                                                                                                if v424.0 == I64 {
                                                                                                                                                                                                                    if let &InstructionData::Binary {
                                                                                                                                                                                                                        opcode: ref v427,
                                                                                                                                                                                                                        args: ref v428,
                                                                                                                                                                                                                    } = &v424.1 {
                                                                                                                                                                                                                        if let &Opcode::Band = v427 {
                                                                                                                                                                                                                            let v429 = C::unpack_value_array_2(ctx, v428);
                                                                                                                                                                                                                            let mut v432 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                            C::inst_data_value_etor(ctx, v429.1, &mut v432);
                                                                                                                                                                                                                            let mut v432 = v432.into_context_iter();
                                                                                                                                                                                                                            while let Some(v433) = v432.next(ctx) {
                                                                                                                                                                                                                                if v433.0 == I64 {
                                                                                                                                                                                                                                    if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                        opcode: ref v436,
                                                                                                                                                                                                                                        imm: v437,
                                                                                                                                                                                                                                    } = &v433.1 {
                                                                                                                                                                                                                                        if let &Opcode::Iconst = v436 {
                                                                                                                                                                                                                                            let v438 = C::u64_from_imm64(ctx, v437);
                                                                                                                                                                                                                                            if v438 == 0xff000000_u64 {
                                                                                                                                                                                                                                                let mut v439 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                C::inst_data_value_etor(ctx, v280.1, &mut v439);
                                                                                                                                                                                                                                                let mut v439 = v439.into_context_iter();
                                                                                                                                                                                                                                                while let Some(v440) = v439.next(ctx) {
                                                                                                                                                                                                                                                    if v440.0 == I64 {
                                                                                                                                                                                                                                                        if let &InstructionData::Binary {
                                                                                                                                                                                                                                                            opcode: ref v558,
                                                                                                                                                                                                                                                            args: ref v559,
                                                                                                                                                                                                                                                        } = &v440.1 {
                                                                                                                                                                                                                                                            if let &Opcode::Band = v558 {
                                                                                                                                                                                                                                                                let v264 = C::unpack_value_array_2(ctx, v263);
                                                                                                                                                                                                                                                                let mut v446 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                C::inst_data_value_etor(ctx, v264.1, &mut v446);
                                                                                                                                                                                                                                                                let mut v446 = v446.into_context_iter();
                                                                                                                                                                                                                                                                while let Some(v447) = v446.next(ctx) {
                                                                                                                                                                                                                                                                    if v447.0 == I64 {
                                                                                                                                                                                                                                                                        if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                            opcode: ref v618,
                                                                                                                                                                                                                                                                            args: ref v619,
                                                                                                                                                                                                                                                                        } = &v447.1 {
                                                                                                                                                                                                                                                                            if let &Opcode::Ushr = v618 {
                                                                                                                                                                                                                                                                                let mut v454 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                C::inst_data_value_etor(ctx, v286.0, &mut v454);
                                                                                                                                                                                                                                                                                let mut v454 = v454.into_context_iter();
                                                                                                                                                                                                                                                                                while let Some(v455) = v454.next(ctx) {
                                                                                                                                                                                                                                                                                    if v455.0 == I64 {
                                                                                                                                                                                                                                                                                        if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                                            opcode: ref v458,
                                                                                                                                                                                                                                                                                            args: ref v459,
                                                                                                                                                                                                                                                                                        } = &v455.1 {
                                                                                                                                                                                                                                                                                            if let &Opcode::Ishl = v458 {
                                                                                                                                                                                                                                                                                                let v460 = C::unpack_value_array_2(ctx, v459);
                                                                                                                                                                                                                                                                                                let v620 = C::unpack_value_array_2(ctx, v619);
                                                                                                                                                                                                                                                                                                if v460.0 == v620.0 {
                                                                                                                                                                                                                                                                                                    let mut v463 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                    C::inst_data_value_etor(ctx, v460.1, &mut v463);
                                                                                                                                                                                                                                                                                                    let mut v463 = v463.into_context_iter();
                                                                                                                                                                                                                                                                                                    while let Some(v464) = v463.next(ctx) {
                                                                                                                                                                                                                                                                                                        if v464.0 == I64 {
                                                                                                                                                                                                                                                                                                            if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                opcode: ref v467,
                                                                                                                                                                                                                                                                                                                imm: v468,
                                                                                                                                                                                                                                                                                                            } = &v464.1 {
                                                                                                                                                                                                                                                                                                                if let &Opcode::Iconst = v467 {
                                                                                                                                                                                                                                                                                                                    let v469 = C::u64_from_imm64(ctx, v468);
                                                                                                                                                                                                                                                                                                                    if v469 == 0x38_u64 {
                                                                                                                                                                                                                                                                                                                        let v472 = C::unpack_value_array_2(ctx, v471);
                                                                                                                                                                                                                                                                                                                        let mut v475 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                        C::inst_data_value_etor(ctx, v472.0, &mut v475);
                                                                                                                                                                                                                                                                                                                        let mut v475 = v475.into_context_iter();
                                                                                                                                                                                                                                                                                                                        while let Some(v476) = v475.next(ctx) {
                                                                                                                                                                                                                                                                                                                            if v476.0 == I64 {
                                                                                                                                                                                                                                                                                                                                if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                                                                                    opcode: ref v479,
                                                                                                                                                                                                                                                                                                                                    args: ref v480,
                                                                                                                                                                                                                                                                                                                                } = &v476.1 {
                                                                                                                                                                                                                                                                                                                                    if let &Opcode::Band = v479 {
                                                                                                                                                                                                                                                                                                                                        let v481 = C::unpack_value_array_2(ctx, v480);
                                                                                                                                                                                                                                                                                                                                        if v460.0 == v481.0 {
                                                                                                                                                                                                                                                                                                                                            let mut v484 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                            C::inst_data_value_etor(ctx, v481.1, &mut v484);
                                                                                                                                                                                                                                                                                                                                            let mut v484 = v484.into_context_iter();
                                                                                                                                                                                                                                                                                                                                            while let Some(v485) = v484.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                if v485.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                    if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                        opcode: ref v488,
                                                                                                                                                                                                                                                                                                                                                        imm: v489,
                                                                                                                                                                                                                                                                                                                                                    } = &v485.1 {
                                                                                                                                                                                                                                                                                                                                                        if let &Opcode::Iconst = v488 {
                                                                                                                                                                                                                                                                                                                                                            let v490 = C::u64_from_imm64(ctx, v489);
                                                                                                                                                                                                                                                                                                                                                            if v490 == 0xff00_u64 {
                                                                                                                                                                                                                                                                                                                                                                let mut v491 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                C::inst_data_value_etor(ctx, v472.1, &mut v491);
                                                                                                                                                                                                                                                                                                                                                                let mut v491 = v491.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                while let Some(v492) = v491.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                    if v492.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                        if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                            opcode: ref v495,
                                                                                                                                                                                                                                                                                                                                                                            imm: v496,
                                                                                                                                                                                                                                                                                                                                                                        } = &v492.1 {
                                                                                                                                                                                                                                                                                                                                                                            if let &Opcode::Iconst = v495 {
                                                                                                                                                                                                                                                                                                                                                                                let v497 = C::u64_from_imm64(ctx, v496);
                                                                                                                                                                                                                                                                                                                                                                                if v497 == 0x28_u64 {
                                                                                                                                                                                                                                                                                                                                                                                    let mut v498 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                    C::inst_data_value_etor(ctx, v406.0, &mut v498);
                                                                                                                                                                                                                                                                                                                                                                                    let mut v498 = v498.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                    while let Some(v499) = v498.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                        if v499.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                            if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                                                                                                                                                opcode: ref v502,
                                                                                                                                                                                                                                                                                                                                                                                                args: ref v503,
                                                                                                                                                                                                                                                                                                                                                                                            } = &v499.1 {
                                                                                                                                                                                                                                                                                                                                                                                                if let &Opcode::Band = v502 {
                                                                                                                                                                                                                                                                                                                                                                                                    let v504 = C::unpack_value_array_2(ctx, v503);
                                                                                                                                                                                                                                                                                                                                                                                                    if v460.0 == v504.0 {
                                                                                                                                                                                                                                                                                                                                                                                                        let mut v507 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                        C::inst_data_value_etor(ctx, v504.1, &mut v507);
                                                                                                                                                                                                                                                                                                                                                                                                        let mut v507 = v507.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                        while let Some(v508) = v507.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                            if v508.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                                                                    opcode: ref v511,
                                                                                                                                                                                                                                                                                                                                                                                                                    imm: v512,
                                                                                                                                                                                                                                                                                                                                                                                                                } = &v508.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                    if let &Opcode::Iconst = v511 {
                                                                                                                                                                                                                                                                                                                                                                                                                        let v513 = C::u64_from_imm64(ctx, v512);
                                                                                                                                                                                                                                                                                                                                                                                                                        if v513 == 0xff0000_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                            let v516 = C::unpack_value_array_2(ctx, v515);
                                                                                                                                                                                                                                                                                                                                                                                                                            let mut v519 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                            C::inst_data_value_etor(ctx, v516.0, &mut v519);
                                                                                                                                                                                                                                                                                                                                                                                                                            let mut v519 = v519.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                            while let Some(v520) = v519.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                if v520.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                    if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                                                                                                                                                                                        opcode: ref v523,
                                                                                                                                                                                                                                                                                                                                                                                                                                        args: ref v524,
                                                                                                                                                                                                                                                                                                                                                                                                                                    } = &v520.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                        if let &Opcode::Band = v523 {
                                                                                                                                                                                                                                                                                                                                                                                                                                            let v525 = C::unpack_value_array_2(ctx, v524);
                                                                                                                                                                                                                                                                                                                                                                                                                                            if v460.0 == v525.0 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                let mut v528 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                C::inst_data_value_etor(ctx, v525.1, &mut v528);
                                                                                                                                                                                                                                                                                                                                                                                                                                                let mut v528 = v528.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                while let Some(v529) = v528.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                    if v529.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                        if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                                                                                                            opcode: ref v532,
                                                                                                                                                                                                                                                                                                                                                                                                                                                            imm: v533,
                                                                                                                                                                                                                                                                                                                                                                                                                                                        } = &v529.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                            if let &Opcode::Iconst = v532 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                let v534 = C::u64_from_imm64(ctx, v533);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                if v534 == 0xff000000_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mut v535 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    C::inst_data_value_etor(ctx, v516.1, &mut v535);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mut v535 = v535.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    while let Some(v536) = v535.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if v536.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                opcode: ref v539,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                imm: v540,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } = &v536.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if let &Opcode::Iconst = v539 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let v541 = C::u64_from_imm64(ctx, v540);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if v541 == 0x8_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mut v542 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        C::inst_data_value_etor(ctx, v429.0, &mut v542);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mut v542 = v542.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        while let Some(v543) = v542.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if v543.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opcode: ref v546,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    args: ref v547,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } = &v543.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if let &Opcode::Ushr = v546 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let v548 = C::unpack_value_array_2(ctx, v547);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if v460.0 == v548.0 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mut v551 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            C::inst_data_value_etor(ctx, v548.1, &mut v551);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mut v551 = v551.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            while let Some(v552) = v551.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if v552.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opcode: ref v555,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        imm: v556,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } = &v552.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if let &Opcode::Iconst = v555 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let v557 = C::u64_from_imm64(ctx, v556);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if v557 == 0x8_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let v560 = C::unpack_value_array_2(ctx, v559);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mut v563 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                C::inst_data_value_etor(ctx, v560.0, &mut v563);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mut v563 = v563.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                while let Some(v564) = v563.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if v564.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            opcode: ref v567,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            args: ref v568,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } = &v564.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if let &Opcode::Ushr = v567 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let v569 = C::unpack_value_array_2(ctx, v568);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if v460.0 == v569.0 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mut v572 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    C::inst_data_value_etor(ctx, v569.1, &mut v572);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mut v572 = v572.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    while let Some(v573) = v572.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if v573.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                opcode: ref v576,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                imm: v577,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } = &v573.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if let &Opcode::Iconst = v576 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let v578 = C::u64_from_imm64(ctx, v577);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if v578 == 0x18_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mut v579 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        C::inst_data_value_etor(ctx, v560.1, &mut v579);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mut v579 = v579.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        while let Some(v580) = v579.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if v580.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opcode: ref v583,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    imm: v584,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } = &v580.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if let &Opcode::Iconst = v583 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let v585 = C::u64_from_imm64(ctx, v584);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if v585 == 0xff0000_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mut v586 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            C::inst_data_value_etor(ctx, v264.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::Band = v590 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let v592 = C::unpack_value_array_2(ctx, v591);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mut v595 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            C::inst_data_value_etor(ctx, v592.0, &mut v595);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mut v595 = v595.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            while let Some(v596) = v595.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if v596.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opcode: ref v599,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        args: ref v600,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } = &v596.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if let &Opcode::Ushr = v599 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let v601 = C::unpack_value_array_2(ctx, v600);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if v460.0 == v601.0 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mut v604 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                C::inst_data_value_etor(ctx, v601.1, &mut v604);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mut v604 = v604.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                while let Some(v605) = v604.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if v605.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            opcode: ref v608,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            imm: v609,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } = &v605.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if let &Opcode::Iconst = v608 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let v610 = C::u64_from_imm64(ctx, v609);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if v610 == 0x28_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mut v611 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    C::inst_data_value_etor(ctx, v592.1, &mut v611);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mut v611 = v611.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    while let Some(v612) = v611.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if v612.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                opcode: ref v615,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                imm: v616,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } = &v612.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if let &Opcode::Iconst = v615 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let v617 = C::u64_from_imm64(ctx, v616);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if v617 == 0xff00_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mut v623 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        C::inst_data_value_etor(ctx, v620.1, &mut v623);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mut v623 = v623.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        while let Some(v624) = v623.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if v624.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opcode: ref v627,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    imm: v628,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } = &v624.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if let &Opcode::Iconst = v627 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let v629 = C::u64_from_imm64(ctx, v628);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if v629 == 0x38_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let v630 = constructor_bswap(ctx, v2.0, v460.0);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            // Rule at src/opts/bitops.isle line 163.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            returns.extend(Some(v630));
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            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 v879 = constructor_bxor(ctx, v2.0, v99.1, v107);
                                                                                                // Rule at src/opts/bitops.isle line 570.
                                                                                                returns.extend(Some(v879));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                        if v107 == v135.0 {
                                                                                            if v99.1 == v135.1 {
                                                                                                let v879 = constructor_bxor(ctx, v2.0, v99.1, v107);
                                                                                                // Rule at src/opts/bitops.isle line 572.
                                                                                                returns.extend(Some(v879));
                                                                                                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 v877 = constructor_bxor(ctx, v2.0, v99.0, v114);
                                                                                                // Rule at src/opts/bitops.isle line 566.
                                                                                                returns.extend(Some(v877));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                        if v114 == v135.0 {
                                                                                            if v99.0 == v135.1 {
                                                                                                let v877 = constructor_bxor(ctx, v2.0, v99.0, v114);
                                                                                                // Rule at src/opts/bitops.isle line 568.
                                                                                                returns.extend(Some(v877));
                                                                                                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 622.
                                                                                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 628.
                                                                                returns.extend(Some(v241));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                            let v241 = constructor_bor(ctx, v2.0, v99.1, v99.0);
                                                                            let v800 = constructor_bor(ctx, v2.0, v241, v135.1);
                                                                            // Rule at src/opts/bitops.isle line 425.
                                                                            returns.extend(Some(v800));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            let v240 = constructor_bor(ctx, v2.0, v99.0, v99.1);
                                                                            let v798 = constructor_bor(ctx, v2.0, v240, v135.1);
                                                                            // Rule at src/opts/bitops.isle line 452.
                                                                            returns.extend(Some(v798));
                                                                            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 624.
                                                                                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 626.
                                                                                returns.extend(Some(v241));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                            let v241 = constructor_bor(ctx, v2.0, v99.1, v99.0);
                                                                            let v804 = constructor_bor(ctx, v2.0, v241, v135.0);
                                                                            // Rule at src/opts/bitops.isle line 429.
                                                                            returns.extend(Some(v804));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            let v240 = constructor_bor(ctx, v2.0, v99.0, v99.1);
                                                                            let v802 = constructor_bor(ctx, v2.0, v240, v135.0);
                                                                            // Rule at src/opts/bitops.isle line 454.
                                                                            returns.extend(Some(v802));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v99.1 == v135.0 {
                                                                            let v240 = constructor_bor(ctx, v2.0, v99.0, v99.1);
                                                                            let v798 = constructor_bor(ctx, v2.0, v240, v135.1);
                                                                            // Rule at src/opts/bitops.isle line 423.
                                                                            returns.extend(Some(v798));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            let v241 = constructor_bor(ctx, v2.0, v99.1, v99.0);
                                                                            let v800 = constructor_bor(ctx, v2.0, v241, v135.1);
                                                                            // Rule at src/opts/bitops.isle line 456.
                                                                            returns.extend(Some(v800));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v99.1 == v135.1 {
                                                                            let v240 = constructor_bor(ctx, v2.0, v99.0, v99.1);
                                                                            let v802 = constructor_bor(ctx, v2.0, v240, v135.0);
                                                                            // Rule at src/opts/bitops.isle line 427.
                                                                            returns.extend(Some(v802));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            let v241 = constructor_bor(ctx, v2.0, v99.1, v99.0);
                                                                            let v804 = constructor_bor(ctx, v2.0, v241, v135.0);
                                                                            // Rule at src/opts/bitops.isle line 458.
                                                                            returns.extend(Some(v804));
                                                                            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 v783 = constructor_bxor(ctx, v2.0, v286.0, v286.1);
                                                                                                let v784 = constructor_bor(ctx, v2.0, v783, v99.1);
                                                                                                // Rule at src/opts/bitops.isle line 392.
                                                                                                returns.extend(Some(v784));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v788 = constructor_bxor(ctx, v2.0, v286.1, v286.0);
                                                                                                let v789 = constructor_bor(ctx, v2.0, v788, v99.1);
                                                                                                // Rule at src/opts/bitops.isle line 407.
                                                                                                returns.extend(Some(v789));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                        if v135.0 == v286.1 {
                                                                                            if v135.1 == v286.0 {
                                                                                                let v788 = constructor_bxor(ctx, v2.0, v286.1, v286.0);
                                                                                                let v789 = constructor_bor(ctx, v2.0, v788, v99.1);
                                                                                                // Rule at src/opts/bitops.isle line 397.
                                                                                                returns.extend(Some(v789));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v783 = constructor_bxor(ctx, v2.0, v286.0, v286.1);
                                                                                                let v784 = constructor_bor(ctx, v2.0, v783, v99.1);
                                                                                                // Rule at src/opts/bitops.isle line 402.
                                                                                                returns.extend(Some(v784));
                                                                                                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 v786 = constructor_bxor(ctx, v2.0, v270.0, v270.1);
                                                                                                let v787 = constructor_bor(ctx, v2.0, v786, v99.0);
                                                                                                // Rule at src/opts/bitops.isle line 394.
                                                                                                returns.extend(Some(v787));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v790 = constructor_bxor(ctx, v2.0, v270.1, v270.0);
                                                                                                let v791 = constructor_bor(ctx, v2.0, v790, v99.0);
                                                                                                // Rule at src/opts/bitops.isle line 409.
                                                                                                returns.extend(Some(v791));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                        if v135.0 == v270.1 {
                                                                                            if v135.1 == v270.0 {
                                                                                                let v790 = constructor_bxor(ctx, v2.0, v270.1, v270.0);
                                                                                                let v791 = constructor_bor(ctx, v2.0, v790, v99.0);
                                                                                                // Rule at src/opts/bitops.isle line 399.
                                                                                                returns.extend(Some(v791));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v786 = constructor_bxor(ctx, v2.0, v270.0, v270.1);
                                                                                                let v787 = constructor_bor(ctx, v2.0, v786, v99.0);
                                                                                                // Rule at src/opts/bitops.isle line 404.
                                                                                                returns.extend(Some(v787));
                                                                                                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 v785 = constructor_bor(ctx, v2.0, v238, v135.0);
                                                                                                // Rule at src/opts/bitops.isle line 393.
                                                                                                returns.extend(Some(v785));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v239 = constructor_bxor(ctx, v2.0, v99.1, v99.0);
                                                                                                let v793 = constructor_bor(ctx, v2.0, v239, v135.0);
                                                                                                // Rule at src/opts/bitops.isle line 408.
                                                                                                returns.extend(Some(v793));
                                                                                                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 v785 = constructor_bor(ctx, v2.0, v238, v135.0);
                                                                                                // Rule at src/opts/bitops.isle line 398.
                                                                                                returns.extend(Some(v785));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v239 = constructor_bxor(ctx, v2.0, v99.1, v99.0);
                                                                                                let v793 = constructor_bor(ctx, v2.0, v239, v135.0);
                                                                                                // Rule at src/opts/bitops.isle line 403.
                                                                                                returns.extend(Some(v793));
                                                                                                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 v782 = constructor_bor(ctx, v2.0, v238, v135.1);
                                                                                                // Rule at src/opts/bitops.isle line 391.
                                                                                                returns.extend(Some(v782));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v239 = constructor_bxor(ctx, v2.0, v99.1, v99.0);
                                                                                                let v792 = constructor_bor(ctx, v2.0, v239, v135.1);
                                                                                                // Rule at src/opts/bitops.isle line 406.
                                                                                                returns.extend(Some(v792));
                                                                                                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 v782 = constructor_bor(ctx, v2.0, v238, v135.1);
                                                                                                // Rule at src/opts/bitops.isle line 396.
                                                                                                returns.extend(Some(v782));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                let v239 = constructor_bxor(ctx, v2.0, v99.1, v99.0);
                                                                                                let v792 = constructor_bor(ctx, v2.0, v239, v135.1);
                                                                                                // Rule at src/opts/bitops.isle line 401.
                                                                                                returns.extend(Some(v792));
                                                                                                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 v837 = constructor_band(ctx, v2.0, v135.1, v30);
                                                                        let v838 = constructor_bnot(ctx, v2.0, v837);
                                                                        // Rule at src/opts/bitops.isle line 495.
                                                                        returns.extend(Some(v838));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v30 == v135.1 {
                                                                        let v834 = constructor_band(ctx, v2.0, v135.0, v30);
                                                                        let v835 = constructor_bnot(ctx, v2.0, v834);
                                                                        // Rule at src/opts/bitops.isle line 493.
                                                                        returns.extend(Some(v835));
                                                                        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 v359 = constructor_bor(ctx, v2.0, v135.0, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 525.
                                                                            returns.extend(Some(v359));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.0 == v264.1 {
                                                                            let v359 = constructor_bor(ctx, v2.0, v135.0, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 529.
                                                                            returns.extend(Some(v359));
                                                                            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 v723 = constructor_bxor(ctx, v2.0, v264.1, v135.0);
                                                                            let v724 = constructor_bor(ctx, v2.0, v723, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 304.
                                                                            returns.extend(Some(v724));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.0 == v264.1 {
                                                                            let v731 = constructor_bxor(ctx, v2.0, v264.0, v135.0);
                                                                            let v732 = constructor_bor(ctx, v2.0, v731, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 308.
                                                                            returns.extend(Some(v732));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v636,
                                                            arg: v637,
                                                        } => {
                                                            if let &Opcode::Bnot = v636 {
                                                                if v7.0 == v637 {
                                                                    if v2.0 == v259.0 {
                                                                        let v756 = constructor_bnot(ctx, v2.0, v135.0);
                                                                        let v895 = constructor_bor(ctx, v2.0, v7.0, v756);
                                                                        // Rule at src/opts/bitops.isle line 606.
                                                                        returns.extend(Some(v895));
                                                                        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 v871 = constructor_bor(ctx, v2.0, v135.1, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 527.
                                                                            returns.extend(Some(v871));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.0 == v280.1 {
                                                                            let v871 = constructor_bor(ctx, v2.0, v135.1, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 531.
                                                                            returns.extend(Some(v871));
                                                                            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 v719 = constructor_bxor(ctx, v2.0, v280.1, v135.1);
                                                                            let v720 = constructor_bor(ctx, v2.0, v719, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 302.
                                                                            returns.extend(Some(v720));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.0 == v280.1 {
                                                                            let v727 = constructor_bxor(ctx, v2.0, v280.0, v135.1);
                                                                            let v728 = constructor_bor(ctx, v2.0, v727, v7.0);
                                                                            // Rule at src/opts/bitops.isle line 306.
                                                                            returns.extend(Some(v728));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v639,
                                                            arg: v640,
                                                        } => {
                                                            if let &Opcode::Bnot = v639 {
                                                                if v7.0 == v640 {
                                                                    if v2.0 == v275.0 {
                                                                        let v753 = constructor_bnot(ctx, v2.0, v135.1);
                                                                        let v893 = constructor_bor(ctx, v2.0, v7.0, v753);
                                                                        // Rule at src/opts/bitops.isle line 604.
                                                                        returns.extend(Some(v893));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                if v7.0 == v135.0 {
                                                    let v631 = constructor_bor(ctx, v2.0, v7.0, v135.1);
                                                    // Rule at src/opts/bitops.isle line 412.
                                                    returns.extend(Some(v631));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.0 == v135.1 {
                                                    let v794 = constructor_bor(ctx, v2.0, v7.0, v135.0);
                                                    // Rule at src/opts/bitops.isle line 414.
                                                    returns.extend(Some(v794));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        &Opcode::Ishl => {
                                            let v1386 = C::ty_int(ctx, v2.0);
                                            if let Some(v1387) = v1386 {
                                                if v11.0 == v1387 {
                                                    let mut v18 = C::inst_data_value_etor_returns::default();
                                                    C::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 v1148,
                                                                                            imm: v1149,
                                                                                        } = &v259.1 {
                                                                                            if let &Opcode::Iconst = v1148 {
                                                                                                let v360 = C::u64_from_imm64(ctx, v128);
                                                                                                let v1909 = C::lane_type(ctx, v1387);
                                                                                                let v1910 = C::ty_bits_u64(ctx, v1909);
                                                                                                let v1415 = C::u64_from_imm64(ctx, v1149);
                                                                                                let v1914 = C::u64_wrapping_sub(ctx, v1910, v1415);
                                                                                                let v1915 = C::u64_eq(ctx, v360, v1914);
                                                                                                if v1915 == true {
                                                                                                    let v1916 = constructor_rotl(ctx, v1387, v99.0, v135.1);
                                                                                                    // Rule at src/opts/shifts.isle line 284.
                                                                                                    returns.extend(Some(v1916));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Ushr => {
                                            let v1386 = C::ty_int(ctx, v2.0);
                                            if let Some(v1387) = v1386 {
                                                if v11.0 == v1387 {
                                                    let mut v18 = C::inst_data_value_etor_returns::default();
                                                    C::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 v1148,
                                                                                            imm: v1149,
                                                                                        } = &v259.1 {
                                                                                            if let &Opcode::Iconst = v1148 {
                                                                                                let v1415 = C::u64_from_imm64(ctx, v1149);
                                                                                                let v1909 = C::lane_type(ctx, v1387);
                                                                                                let v1910 = C::ty_bits_u64(ctx, v1909);
                                                                                                let v360 = C::u64_from_imm64(ctx, v128);
                                                                                                let v1911 = C::u64_wrapping_sub(ctx, v1910, v360);
                                                                                                let v1912 = C::u64_eq(ctx, v1415, v1911);
                                                                                                if v1912 == true {
                                                                                                    let v1913 = constructor_rotl(ctx, v1387, v99.0, v99.1);
                                                                                                    // Rule at src/opts/shifts.isle line 279.
                                                                                                    returns.extend(Some(v1913));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::IntCompare {
                                    opcode: ref v764,
                                    args: ref v765,
                                    cond: ref v766,
                                } => {
                                    if let &Opcode::Icmp = v764 {
                                        let mut v18 = C::inst_data_value_etor_returns::default();
                                        C::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 v758,
                                                args: ref v759,
                                                cond: ref v760,
                                            } = &v19.1 {
                                                if let &Opcode::Icmp = v758 {
                                                    if v11.0 == v19.0 {
                                                        match v760 {
                                                            &IntCC::Equal => {
                                                                match v766 {
                                                                    &IntCC::SignedGreaterThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v761 = C::unpack_value_array_2(ctx, v759);
                                                                            let v767 = C::unpack_value_array_2(ctx, v765);
                                                                            if v761.0 == v767.0 {
                                                                                if v761.1 == v767.1 {
                                                                                    let v781 = constructor_sle(ctx, v2.0, v761.1, v761.0);
                                                                                    // Rule at src/opts/bitops.isle line 388.
                                                                                    returns.extend(Some(v781));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                            if v761.0 == v767.1 {
                                                                                if v761.1 == v767.0 {
                                                                                    let v780 = constructor_sle(ctx, v2.0, v761.0, v761.1);
                                                                                    // Rule at src/opts/bitops.isle line 386.
                                                                                    returns.extend(Some(v780));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedLessThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v761 = C::unpack_value_array_2(ctx, v759);
                                                                            let v767 = C::unpack_value_array_2(ctx, v765);
                                                                            if v761.0 == v767.0 {
                                                                                if v761.1 == v767.1 {
                                                                                    let v780 = constructor_sle(ctx, v2.0, v761.0, v761.1);
                                                                                    // Rule at src/opts/bitops.isle line 380.
                                                                                    returns.extend(Some(v780));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                            if v761.0 == v767.1 {
                                                                                if v761.1 == v767.0 {
                                                                                    let v781 = constructor_sle(ctx, v2.0, v761.1, v761.0);
                                                                                    // Rule at src/opts/bitops.isle line 382.
                                                                                    returns.extend(Some(v781));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedGreaterThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v761 = C::unpack_value_array_2(ctx, v759);
                                                                            let v767 = C::unpack_value_array_2(ctx, v765);
                                                                            if v761.0 == v767.0 {
                                                                                if v761.1 == v767.1 {
                                                                                    let v779 = constructor_ule(ctx, v2.0, v761.1, v761.0);
                                                                                    // Rule at src/opts/bitops.isle line 376.
                                                                                    returns.extend(Some(v779));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                            if v761.0 == v767.1 {
                                                                                if v761.1 == v767.0 {
                                                                                    let v778 = constructor_ule(ctx, v2.0, v761.0, v761.1);
                                                                                    // Rule at src/opts/bitops.isle line 374.
                                                                                    returns.extend(Some(v778));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v761 = C::unpack_value_array_2(ctx, v759);
                                                                            let v767 = C::unpack_value_array_2(ctx, v765);
                                                                            if v761.0 == v767.0 {
                                                                                if v761.1 == v767.1 {
                                                                                    let v778 = constructor_ule(ctx, v2.0, v761.0, v761.1);
                                                                                    // Rule at src/opts/bitops.isle line 368.
                                                                                    returns.extend(Some(v778));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                            if v761.0 == v767.1 {
                                                                                if v761.1 == v767.0 {
                                                                                    let v779 = constructor_ule(ctx, v2.0, v761.1, v761.0);
                                                                                    // Rule at src/opts/bitops.isle line 370.
                                                                                    returns.extend(Some(v779));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                            &IntCC::SignedGreaterThan => {
                                                                match v766 {
                                                                    &IntCC::Equal => {
                                                                        if v2.0 == v11.0 {
                                                                            let v761 = C::unpack_value_array_2(ctx, v759);
                                                                            let v767 = C::unpack_value_array_2(ctx, v765);
                                                                            if v761.0 == v767.0 {
                                                                                if v761.1 == v767.1 {
                                                                                    let v781 = constructor_sle(ctx, v2.0, v761.1, v761.0);
                                                                                    // Rule at src/opts/bitops.isle line 387.
                                                                                    returns.extend(Some(v781));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                            if v761.0 == v767.1 {
                                                                                if v761.1 == v767.0 {
                                                                                    let v781 = constructor_sle(ctx, v2.0, v761.1, v761.0);
                                                                                    // Rule at src/opts/bitops.isle line 385.
                                                                                    returns.extend(Some(v781));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedGreaterThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v761 = C::unpack_value_array_2(ctx, v759);
                                                                            let v767 = C::unpack_value_array_2(ctx, v765);
                                                                            if v761.0 == v767.1 {
                                                                                if v761.1 == v767.0 {
                                                                                    let v771 = constructor_ne(ctx, v2.0, v761.1, v761.0);
                                                                                    // Rule at src/opts/bitops.isle line 343.
                                                                                    returns.extend(Some(v771));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    let v770 = constructor_ne(ctx, v2.0, v761.0, v761.1);
                                                                                    // Rule at src/opts/bitops.isle line 344.
                                                                                    returns.extend(Some(v770));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedLessThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v761 = C::unpack_value_array_2(ctx, v759);
                                                                            let v767 = C::unpack_value_array_2(ctx, v765);
                                                                            if v761.0 == v767.0 {
                                                                                if v761.1 == v767.1 {
                                                                                    let v770 = constructor_ne(ctx, v2.0, v761.0, v761.1);
                                                                                    // Rule at src/opts/bitops.isle line 340.
                                                                                    returns.extend(Some(v770));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    let v771 = constructor_ne(ctx, v2.0, v761.1, v761.0);
                                                                                    // Rule at src/opts/bitops.isle line 345.
                                                                                    returns.extend(Some(v771));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                            &IntCC::SignedLessThan => {
                                                                match v766 {
                                                                    &IntCC::Equal => {
                                                                        if v2.0 == v11.0 {
                                                                            let v761 = C::unpack_value_array_2(ctx, v759);
                                                                            let v767 = C::unpack_value_array_2(ctx, v765);
                                                                            if v761.0 == v767.0 {
                                                                                if v761.1 == v767.1 {
                                                                                    let v780 = constructor_sle(ctx, v2.0, v761.0, v761.1);
                                                                                    // Rule at src/opts/bitops.isle line 379.
                                                                                    returns.extend(Some(v780));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                            if v761.0 == v767.1 {
                                                                                if v761.1 == v767.0 {
                                                                                    let v780 = constructor_sle(ctx, v2.0, v761.0, v761.1);
                                                                                    // Rule at src/opts/bitops.isle line 381.
                                                                                    returns.extend(Some(v780));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedGreaterThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v761 = C::unpack_value_array_2(ctx, v759);
                                                                            let v767 = C::unpack_value_array_2(ctx, v765);
                                                                            if v761.0 == v767.0 {
                                                                                if v761.1 == v767.1 {
                                                                                    let v770 = constructor_ne(ctx, v2.0, v761.0, v761.1);
                                                                                    // Rule at src/opts/bitops.isle line 339.
                                                                                    returns.extend(Some(v770));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    let v771 = constructor_ne(ctx, v2.0, v761.1, v761.0);
                                                                                    // Rule at src/opts/bitops.isle line 346.
                                                                                    returns.extend(Some(v771));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedLessThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v761 = C::unpack_value_array_2(ctx, v759);
                                                                            let v767 = C::unpack_value_array_2(ctx, v765);
                                                                            if v761.0 == v767.1 {
                                                                                if v761.1 == v767.0 {
                                                                                    let v770 = constructor_ne(ctx, v2.0, v761.0, v761.1);
                                                                                    // Rule at src/opts/bitops.isle line 341.
                                                                                    returns.extend(Some(v770));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    let v771 = constructor_ne(ctx, v2.0, v761.1, v761.0);
                                                                                    // Rule at src/opts/bitops.isle line 342.
                                                                                    returns.extend(Some(v771));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                            &IntCC::UnsignedGreaterThan => {
                                                                match v766 {
                                                                    &IntCC::Equal => {
                                                                        if v2.0 == v11.0 {
                                                                            let v761 = C::unpack_value_array_2(ctx, v759);
                                                                            let v767 = C::unpack_value_array_2(ctx, v765);
                                                                            if v761.0 == v767.0 {
                                                                                if v761.1 == v767.1 {
                                                                                    let v779 = constructor_ule(ctx, v2.0, v761.1, v761.0);
                                                                                    // Rule at src/opts/bitops.isle line 375.
                                                                                    returns.extend(Some(v779));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                            if v761.0 == v767.1 {
                                                                                if v761.1 == v767.0 {
                                                                                    let v779 = constructor_ule(ctx, v2.0, v761.1, v761.0);
                                                                                    // Rule at src/opts/bitops.isle line 373.
                                                                                    returns.extend(Some(v779));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedGreaterThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v761 = C::unpack_value_array_2(ctx, v759);
                                                                            let v767 = C::unpack_value_array_2(ctx, v765);
                                                                            if v761.0 == v767.1 {
                                                                                if v761.1 == v767.0 {
                                                                                    let v771 = constructor_ne(ctx, v2.0, v761.1, v761.0);
                                                                                    // Rule at src/opts/bitops.isle line 353.
                                                                                    returns.extend(Some(v771));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    let v770 = constructor_ne(ctx, v2.0, v761.0, v761.1);
                                                                                    // Rule at src/opts/bitops.isle line 354.
                                                                                    returns.extend(Some(v770));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v761 = C::unpack_value_array_2(ctx, v759);
                                                                            let v767 = C::unpack_value_array_2(ctx, v765);
                                                                            if v761.0 == v767.0 {
                                                                                if v761.1 == v767.1 {
                                                                                    let v770 = constructor_ne(ctx, v2.0, v761.0, v761.1);
                                                                                    // Rule at src/opts/bitops.isle line 350.
                                                                                    returns.extend(Some(v770));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    let v771 = constructor_ne(ctx, v2.0, v761.1, v761.0);
                                                                                    // Rule at src/opts/bitops.isle line 355.
                                                                                    returns.extend(Some(v771));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                            &IntCC::UnsignedLessThan => {
                                                                match v766 {
                                                                    &IntCC::Equal => {
                                                                        if v2.0 == v11.0 {
                                                                            let v761 = C::unpack_value_array_2(ctx, v759);
                                                                            let v767 = C::unpack_value_array_2(ctx, v765);
                                                                            if v761.0 == v767.0 {
                                                                                if v761.1 == v767.1 {
                                                                                    let v778 = constructor_ule(ctx, v2.0, v761.0, v761.1);
                                                                                    // Rule at src/opts/bitops.isle line 367.
                                                                                    returns.extend(Some(v778));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                            if v761.0 == v767.1 {
                                                                                if v761.1 == v767.0 {
                                                                                    let v778 = constructor_ule(ctx, v2.0, v761.0, v761.1);
                                                                                    // Rule at src/opts/bitops.isle line 369.
                                                                                    returns.extend(Some(v778));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedGreaterThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v761 = C::unpack_value_array_2(ctx, v759);
                                                                            let v767 = C::unpack_value_array_2(ctx, v765);
                                                                            if v761.0 == v767.0 {
                                                                                if v761.1 == v767.1 {
                                                                                    let v770 = constructor_ne(ctx, v2.0, v761.0, v761.1);
                                                                                    // Rule at src/opts/bitops.isle line 349.
                                                                                    returns.extend(Some(v770));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    let v771 = constructor_ne(ctx, v2.0, v761.1, v761.0);
                                                                                    // Rule at src/opts/bitops.isle line 356.
                                                                                    returns.extend(Some(v771));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v761 = C::unpack_value_array_2(ctx, v759);
                                                                            let v767 = C::unpack_value_array_2(ctx, v765);
                                                                            if v761.0 == v767.1 {
                                                                                if v761.1 == v767.0 {
                                                                                    let v770 = constructor_ne(ctx, v2.0, v761.0, v761.1);
                                                                                    // Rule at src/opts/bitops.isle line 351.
                                                                                    returns.extend(Some(v770));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    let v771 = constructor_ne(ctx, v2.0, v761.1, v761.0);
                                                                                    // Rule at src/opts/bitops.isle line 352.
                                                                                    returns.extend(Some(v771));
                                                                                    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 v1485 = constructor_intcc_comparable(ctx, v760, v766);
                                                                if let Some(v1486) = v1485 {
                                                                    let v761 = C::unpack_value_array_2(ctx, v759);
                                                                    let v767 = C::unpack_value_array_2(ctx, v765);
                                                                    if v761.0 == v767.0 {
                                                                        if v761.1 == v767.1 {
                                                                            let v1487 = constructor_decompose_intcc(ctx, v760);
                                                                            let v1488 = constructor_decompose_intcc(ctx, v766);
                                                                            let v1491 = C::u64_or(ctx, v1487, v1488);
                                                                            let v1492 = constructor_compose_icmp(ctx, v335, v1491, v1486, v761.0, v761.1);
                                                                            // Rule at src/opts/icmp.isle line 183.
                                                                            returns.extend(Some(v1492));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v26,
                                    arg: v27,
                                } => {
                                    match v26 {
                                        &Opcode::Splat => {
                                            let v2006 = C::ty_vector_not_float(ctx, v2.0);
                                            if let Some(v2007) = v2006 {
                                                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 v1869 = C::lane_type(ctx, v2.0);
                                                                    let v2010 = constructor_bor(ctx, v1869, v30, v27);
                                                                    let v2011 = constructor_splat(ctx, v2.0, v2010);
                                                                    // Rule at src/opts/vector.isle line 18.
                                                                    returns.extend(Some(v2011));
                                                                    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 v648 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v27, &mut v648);
                                                                        let mut v648 = v648.into_context_iter();
                                                                        while let Some(v649) = v648.next(ctx) {
                                                                            if let &InstructionData::Binary {
                                                                                opcode: ref v652,
                                                                                args: ref v653,
                                                                            } = &v649.1 {
                                                                                match v652 {
                                                                                    &Opcode::Bor => {
                                                                                        if v2.0 == v649.0 {
                                                                                            let v99 = C::unpack_value_array_2(ctx, v98);
                                                                                            let v654 = C::unpack_value_array_2(ctx, v653);
                                                                                            if v99.0 == v654.0 {
                                                                                                if v99.1 == v654.1 {
                                                                                                    let v238 = constructor_bxor(ctx, v2.0, v99.0, v99.1);
                                                                                                    let v657 = constructor_bnot(ctx, v2.0, v238);
                                                                                                    // Rule at src/opts/bitops.isle line 679.
                                                                                                    returns.extend(Some(v657));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    let v239 = constructor_bxor(ctx, v2.0, v99.1, v99.0);
                                                                                                    let v671 = constructor_bnot(ctx, v2.0, v239);
                                                                                                    // Rule at src/opts/bitops.isle line 685.
                                                                                                    returns.extend(Some(v671));
                                                                                                    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 == v654.1 {
                                                                                                                if v2.0 == v110.0 {
                                                                                                                    let v935 = constructor_bnot(ctx, v2.0, v114);
                                                                                                                    // Rule at src/opts/bitops.isle line 665.
                                                                                                                    returns.extend(Some(v935));
                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                            if v99.0 == v654.1 {
                                                                                                if v99.1 == v654.0 {
                                                                                                    let v238 = constructor_bxor(ctx, v2.0, v99.0, v99.1);
                                                                                                    let v657 = constructor_bnot(ctx, v2.0, v238);
                                                                                                    // Rule at src/opts/bitops.isle line 681.
                                                                                                    returns.extend(Some(v657));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    let v239 = constructor_bxor(ctx, v2.0, v99.1, v99.0);
                                                                                                    let v671 = constructor_bnot(ctx, v2.0, v239);
                                                                                                    // Rule at src/opts/bitops.isle line 683.
                                                                                                    returns.extend(Some(v671));
                                                                                                    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 == v654.0 {
                                                                                                                if v2.0 == v110.0 {
                                                                                                                    let v935 = constructor_bnot(ctx, v2.0, v114);
                                                                                                                    // Rule at src/opts/bitops.isle line 663.
                                                                                                                    returns.extend(Some(v935));
                                                                                                                    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 == v654.0 {
                                                                                                                if v99.1 == v654.1 {
                                                                                                                    let v934 = constructor_bnot(ctx, v2.0, v107);
                                                                                                                    // Rule at src/opts/bitops.isle line 659.
                                                                                                                    returns.extend(Some(v934));
                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                }
                                                                                                            }
                                                                                                            if v107 == v654.1 {
                                                                                                                if v99.1 == v654.0 {
                                                                                                                    let v934 = constructor_bnot(ctx, v2.0, v107);
                                                                                                                    // Rule at src/opts/bitops.isle line 661.
                                                                                                                    returns.extend(Some(v934));
                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                    &Opcode::Bxor => {
                                                                                        if v2.0 == v649.0 {
                                                                                            let v99 = C::unpack_value_array_2(ctx, v98);
                                                                                            let v654 = C::unpack_value_array_2(ctx, v653);
                                                                                            if v99.0 == v654.0 {
                                                                                                if v99.1 == v654.1 {
                                                                                                    let v238 = constructor_bxor(ctx, v2.0, v99.0, v99.1);
                                                                                                    let v657 = constructor_bnot(ctx, v2.0, v238);
                                                                                                    // Rule at src/opts/bitops.isle line 237.
                                                                                                    returns.extend(Some(v657));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    let v239 = constructor_bxor(ctx, v2.0, v99.1, v99.0);
                                                                                                    let v671 = constructor_bnot(ctx, v2.0, v239);
                                                                                                    // Rule at src/opts/bitops.isle line 243.
                                                                                                    returns.extend(Some(v671));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                            if v99.0 == v654.1 {
                                                                                                if v99.1 == v654.0 {
                                                                                                    let v238 = constructor_bxor(ctx, v2.0, v99.0, v99.1);
                                                                                                    let v657 = constructor_bnot(ctx, v2.0, v238);
                                                                                                    // Rule at src/opts/bitops.isle line 239.
                                                                                                    returns.extend(Some(v657));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    let v239 = constructor_bxor(ctx, v2.0, v99.1, v99.0);
                                                                                                    let v671 = constructor_bnot(ctx, v2.0, v239);
                                                                                                    // Rule at src/opts/bitops.isle line 241.
                                                                                                    returns.extend(Some(v671));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                    _ => {}
                                                                                }
                                                                            }
                                                                        }
                                                                        let v99 = C::unpack_value_array_2(ctx, v98);
                                                                        if v27 == v99.0 {
                                                                            let v642 = constructor_bnot(ctx, v2.0, v99.0);
                                                                            let v643 = constructor_bor(ctx, v2.0, v99.1, v642);
                                                                            // Rule at src/opts/bitops.isle line 228.
                                                                            returns.extend(Some(v643));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v27 == v99.1 {
                                                                            let v358 = constructor_bor(ctx, v2.0, v99.0, v7.1);
                                                                            // Rule at src/opts/bitops.isle line 52.
                                                                            returns.extend(Some(v358));
                                                                            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 v836 = constructor_bnot(ctx, v2.0, v242);
                                                                            // Rule at src/opts/bitops.isle line 494.
                                                                            returns.extend(Some(v836));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v27 == v99.1 {
                                                                            let v138 = constructor_band(ctx, v2.0, v99.0, v99.1);
                                                                            let v833 = constructor_bnot(ctx, v2.0, v138);
                                                                            // Rule at src/opts/bitops.isle line 492.
                                                                            returns.extend(Some(v833));
                                                                            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 v713 = constructor_band(ctx, v2.0, v30, v27);
                                                                    let v714 = constructor_bnot(ctx, v2.0, v713);
                                                                    // Rule at src/opts/bitops.isle line 297.
                                                                    returns.extend(Some(v714));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    let v715 = constructor_band(ctx, v2.0, v27, v30);
                                                                    let v716 = constructor_bnot(ctx, v2.0, v715);
                                                                    // Rule at src/opts/bitops.isle line 298.
                                                                    returns.extend(Some(v716));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let mut v648 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v27, &mut v648);
                                                let mut v648 = v648.into_context_iter();
                                                while let Some(v649) = v648.next(ctx) {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v652,
                                                        args: ref v653,
                                                    } = &v649.1 {
                                                        match v652 {
                                                            &Opcode::Bor => {
                                                                if v2.0 == v649.0 {
                                                                    let v654 = C::unpack_value_array_2(ctx, v653);
                                                                    if v7.0 == v654.0 {
                                                                        let v745 = constructor_bnot(ctx, v2.0, v654.1);
                                                                        let v746 = constructor_bor(ctx, v2.0, v7.0, v745);
                                                                        // Rule at src/opts/bitops.isle line 323.
                                                                        returns.extend(Some(v746));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v7.0 == v654.1 {
                                                                        let v741 = constructor_bnot(ctx, v2.0, v654.0);
                                                                        let v742 = constructor_bor(ctx, v2.0, v7.0, v741);
                                                                        // Rule at src/opts/bitops.isle line 321.
                                                                        returns.extend(Some(v742));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Bxor => {
                                                                if v2.0 == v649.0 {
                                                                    let v654 = C::unpack_value_array_2(ctx, v653);
                                                                    if v7.0 == v654.0 {
                                                                        let v745 = constructor_bnot(ctx, v2.0, v654.1);
                                                                        let v746 = constructor_bor(ctx, v2.0, v7.0, v745);
                                                                        // Rule at src/opts/bitops.isle line 598.
                                                                        returns.extend(Some(v746));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v7.0 == v654.1 {
                                                                        let v741 = constructor_bnot(ctx, v2.0, v654.0);
                                                                        let v742 = constructor_bor(ctx, v2.0, v7.0, v741);
                                                                        // Rule at src/opts/bitops.isle line 600.
                                                                        returns.extend(Some(v742));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                    }
                                                }
                                            }
                                            let v352 = C::ty_int_vec128(ctx, v2.0);
                                            if let Some(v353) = v352 {
                                                if v11.0 == v353 {
                                                    if v7.0 == v27 {
                                                        let v354 = constructor_iconst_s(ctx, v353, -1_i64);
                                                        let v355 = C::subsume(ctx, v354);
                                                        // Rule at src/opts/bitops.isle line 32.
                                                        returns.extend(Some(v355));
                                                        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 v1364 = C::value_type(ctx, v30);
                                                        let v1395 = C::value_type(ctx, v27);
                                                        if v1364 == v1395 {
                                                            let v1398 = constructor_bor(ctx, v1364, v30, v27);
                                                            let v1399 = constructor_uextend(ctx, v2.0, v1398);
                                                            // Rule at src/opts/extends.isle line 72.
                                                            returns.extend(Some(v1399));
                                                            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 v361 = C::ty_mask(ctx, v2.0);
                                                                            let v16 = C::u64_from_imm64(ctx, v15);
                                                                            let v362 = C::u64_and(ctx, v361, v16);
                                                                            let v360 = C::u64_from_imm64(ctx, v128);
                                                                            let v363 = C::u64_not(ctx, v360);
                                                                            let v364 = C::u64_and(ctx, v361, v363);
                                                                            let v365 = C::u64_eq(ctx, v362, v364);
                                                                            if v365 == true {
                                                                                if v2.0 == v110.0 {
                                                                                    let v358 = constructor_bor(ctx, v2.0, v99.0, v7.1);
                                                                                    // Rule at src/opts/bitops.isle line 72.
                                                                                    returns.extend(Some(v358));
                                                                                    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 v1060 = constructor_bor(ctx, v2.0, v99.1, v7.1);
                                                                                let v1061 = constructor_bor(ctx, v2.0, v99.0, v1060);
                                                                                // Rule at src/opts/cprop.isle line 216.
                                                                                returns.extend(Some(v1061));
                                                                                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 v970 = C::imm64_or(ctx, v335, v23, v15);
                                                                let v971 = constructor_iconst(ctx, v335, v970);
                                                                let v972 = C::subsume(ctx, v971);
                                                                // Rule at src/opts/cprop.isle line 55.
                                                                returns.extend(Some(v972));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        let v1625 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 17.
                                        returns.extend(Some(v1625));
                                        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 v843 = constructor_band(ctx, v2.0, v99.1, v286.1);
                                                                            let v844 = constructor_bor(ctx, v2.0, v843, v286.0);
                                                                            // Rule at src/opts/bitops.isle line 506.
                                                                            returns.extend(Some(v844));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.1 == v286.1 {
                                                                            let v851 = constructor_band(ctx, v2.0, v99.1, v286.0);
                                                                            let v852 = constructor_bor(ctx, v2.0, v851, v286.1);
                                                                            // Rule at src/opts/bitops.isle line 510.
                                                                            returns.extend(Some(v852));
                                                                            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 v813 = constructor_band(ctx, v2.0, v286.1, v99.1);
                                                                            let v814 = constructor_bor(ctx, v2.0, v813, v286.0);
                                                                            // Rule at src/opts/bitops.isle line 446.
                                                                            returns.extend(Some(v814));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.1 == v286.1 {
                                                                            let v805 = constructor_band(ctx, v2.0, v286.0, v99.1);
                                                                            let v806 = constructor_bor(ctx, v2.0, v805, v286.1);
                                                                            // Rule at src/opts/bitops.isle line 442.
                                                                            returns.extend(Some(v806));
                                                                            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 v875 = constructor_bor(ctx, v2.0, v107, v99.1);
                                                                        // Rule at src/opts/bitops.isle line 541.
                                                                        returns.extend(Some(v875));
                                                                        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 v839 = constructor_band(ctx, v2.0, v99.0, v270.1);
                                                                            let v840 = constructor_bor(ctx, v2.0, v839, v270.0);
                                                                            // Rule at src/opts/bitops.isle line 504.
                                                                            returns.extend(Some(v840));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.1 == v270.1 {
                                                                            let v847 = constructor_band(ctx, v2.0, v99.0, v270.0);
                                                                            let v848 = constructor_bor(ctx, v2.0, v847, v270.1);
                                                                            // Rule at src/opts/bitops.isle line 508.
                                                                            returns.extend(Some(v848));
                                                                            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 v817 = constructor_band(ctx, v2.0, v270.1, v99.0);
                                                                            let v818 = constructor_bor(ctx, v2.0, v817, v270.0);
                                                                            // Rule at src/opts/bitops.isle line 448.
                                                                            returns.extend(Some(v818));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.1 == v270.1 {
                                                                            let v809 = constructor_band(ctx, v2.0, v270.0, v99.0);
                                                                            let v810 = constructor_bor(ctx, v2.0, v809, v270.1);
                                                                            // Rule at src/opts/bitops.isle line 444.
                                                                            returns.extend(Some(v810));
                                                                            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 v876 = constructor_bor(ctx, v2.0, v114, v99.0);
                                                                        // Rule at src/opts/bitops.isle line 543.
                                                                        returns.extend(Some(v876));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                if v7.1 == v99.0 {
                                                    // Rule at src/opts/bitops.isle line 220.
                                                    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 195.
                                                    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 196.
                                                    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 v867 = constructor_bor(ctx, v2.0, v99.1, v286.0);
                                                                            // Rule at src/opts/bitops.isle line 526.
                                                                            returns.extend(Some(v867));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.1 == v286.1 {
                                                                            let v859 = constructor_bor(ctx, v2.0, v99.1, v286.1);
                                                                            // Rule at src/opts/bitops.isle line 530.
                                                                            returns.extend(Some(v859));
                                                                            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 v717 = constructor_bxor(ctx, v2.0, v286.1, v99.1);
                                                                            let v718 = constructor_bor(ctx, v2.0, v717, v286.0);
                                                                            // Rule at src/opts/bitops.isle line 301.
                                                                            returns.extend(Some(v718));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.1 == v286.1 {
                                                                            let v725 = constructor_bxor(ctx, v2.0, v286.0, v99.1);
                                                                            let v726 = constructor_bor(ctx, v2.0, v725, v286.1);
                                                                            // Rule at src/opts/bitops.isle line 305.
                                                                            returns.extend(Some(v726));
                                                                            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 v672 = constructor_bnot(ctx, v2.0, v99.1);
                                                                        let v894 = constructor_bor(ctx, v2.0, v107, v672);
                                                                        // Rule at src/opts/bitops.isle line 605.
                                                                        returns.extend(Some(v894));
                                                                        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 v863 = constructor_bor(ctx, v2.0, v99.0, v270.0);
                                                                            // Rule at src/opts/bitops.isle line 524.
                                                                            returns.extend(Some(v863));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.1 == v270.1 {
                                                                            let v855 = constructor_bor(ctx, v2.0, v99.0, v270.1);
                                                                            // Rule at src/opts/bitops.isle line 528.
                                                                            returns.extend(Some(v855));
                                                                            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 v721 = constructor_bxor(ctx, v2.0, v270.1, v99.0);
                                                                            let v722 = constructor_bor(ctx, v2.0, v721, v270.0);
                                                                            // Rule at src/opts/bitops.isle line 303.
                                                                            returns.extend(Some(v722));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                        if v7.1 == v270.1 {
                                                                            let v729 = constructor_bxor(ctx, v2.0, v270.0, v99.0);
                                                                            let v730 = constructor_bor(ctx, v2.0, v729, v270.1);
                                                                            // Rule at src/opts/bitops.isle line 307.
                                                                            returns.extend(Some(v730));
                                                                            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 v642 = constructor_bnot(ctx, v2.0, v99.0);
                                                                        let v896 = constructor_bor(ctx, v2.0, v114, v642);
                                                                        // Rule at src/opts/bitops.isle line 607.
                                                                        returns.extend(Some(v896));
                                                                        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 413.
                                                    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 415.
                                                    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 v658 = C::inst_data_value_etor_returns::default();
                                            C::inst_data_value_etor(ctx, v30, &mut v658);
                                            let mut v658 = v658.into_context_iter();
                                            while let Some(v659) = v658.next(ctx) {
                                                if let &InstructionData::Binary {
                                                    opcode: ref v662,
                                                    args: ref v663,
                                                } = &v659.1 {
                                                    match v662 {
                                                        &Opcode::Bor => {
                                                            if v2.0 == v659.0 {
                                                                let v664 = C::unpack_value_array_2(ctx, v663);
                                                                if v7.1 == v664.0 {
                                                                    let v747 = constructor_bnot(ctx, v2.0, v664.1);
                                                                    let v748 = constructor_bor(ctx, v2.0, v664.0, v747);
                                                                    // Rule at src/opts/bitops.isle line 324.
                                                                    returns.extend(Some(v748));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v7.1 == v664.1 {
                                                                    let v743 = constructor_bnot(ctx, v2.0, v664.0);
                                                                    let v744 = constructor_bor(ctx, v2.0, v664.1, v743);
                                                                    // Rule at src/opts/bitops.isle line 322.
                                                                    returns.extend(Some(v744));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                        &Opcode::Bxor => {
                                                            if v2.0 == v659.0 {
                                                                let v664 = C::unpack_value_array_2(ctx, v663);
                                                                if v7.1 == v664.0 {
                                                                    let v747 = constructor_bnot(ctx, v2.0, v664.1);
                                                                    let v748 = constructor_bor(ctx, v2.0, v664.0, v747);
                                                                    // Rule at src/opts/bitops.isle line 599.
                                                                    returns.extend(Some(v748));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v7.1 == v664.1 {
                                                                    let v743 = constructor_bnot(ctx, v2.0, v664.0);
                                                                    let v744 = constructor_bor(ctx, v2.0, v664.1, v743);
                                                                    // Rule at src/opts/bitops.isle line 601.
                                                                    returns.extend(Some(v744));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                            }
                                        }
                                        if v7.1 == v30 {
                                            let v352 = C::ty_int_vec128(ctx, v2.0);
                                            if let Some(v353) = v352 {
                                                if v19.0 == v353 {
                                                    let v354 = constructor_iconst_s(ctx, v353, -1_i64);
                                                    let v355 = C::subsume(ctx, v354);
                                                    // Rule at src/opts/bitops.isle line 33.
                                                    returns.extend(Some(v355));
                                                    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 v1032 = constructor_bor(ctx, v2.0, v7.1, v7.0);
                                            // Rule at src/opts/cprop.isle line 158.
                                            returns.extend(Some(v1032));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        let v1625 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 15.
                                        returns.extend(Some(v1625));
                                        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 v646 = constructor_bxor(ctx, v2.0, v99.1, v135.1);
                                                                            let v647 = constructor_band(ctx, v2.0, v99.0, v646);
                                                                            // Rule at src/opts/bitops.isle line 232.
                                                                            returns.extend(Some(v647));
                                                                            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 192.
                                                                                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 v636,
                                                                                arg: v637,
                                                                            } = &v259.1 {
                                                                                if let &Opcode::Bnot = v636 {
                                                                                    if v2.0 == v259.0 {
                                                                                        let v886 = constructor_band(ctx, v2.0, v30, v637);
                                                                                        let v887 = constructor_bnot(ctx, v2.0, v886);
                                                                                        // Rule at src/opts/bitops.isle line 577.
                                                                                        returns.extend(Some(v887));
                                                                                        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 v639,
                                                                                arg: v640,
                                                                            } = &v275.1 {
                                                                                if let &Opcode::Bnot = v639 {
                                                                                    if v2.0 == v275.0 {
                                                                                        let v889 = constructor_band(ctx, v2.0, v30, v640);
                                                                                        let v890 = constructor_bnot(ctx, v2.0, v889);
                                                                                        // Rule at src/opts/bitops.isle line 579.
                                                                                        returns.extend(Some(v890));
                                                                                        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 v636,
                                                        arg: v637,
                                                    } = &v259.1 {
                                                        if let &Opcode::Bnot = v636 {
                                                            if v2.0 == v259.0 {
                                                                if v7.0 == v637 {
                                                                    let v794 = constructor_bor(ctx, v2.0, v7.0, v135.0);
                                                                    // Rule at src/opts/bitops.isle line 585.
                                                                    returns.extend(Some(v794));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                let v930 = constructor_band(ctx, v2.0, v637, v135.0);
                                                                let v931 = constructor_bxor(ctx, v2.0, v7.0, v135.0);
                                                                let v932 = constructor_bxor(ctx, v2.0, v930, v931);
                                                                // Rule at src/opts/bitops.isle line 653.
                                                                returns.extend(Some(v932));
                                                                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 v639,
                                                        arg: v640,
                                                    } = &v275.1 {
                                                        if let &Opcode::Bnot = v639 {
                                                            if v2.0 == v275.0 {
                                                                if v7.0 == v640 {
                                                                    let v631 = constructor_bor(ctx, v2.0, v7.0, v135.1);
                                                                    // Rule at src/opts/bitops.isle line 583.
                                                                    returns.extend(Some(v631));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                let v925 = constructor_band(ctx, v2.0, v640, v135.1);
                                                                let v926 = constructor_bxor(ctx, v2.0, v7.0, v135.1);
                                                                let v927 = constructor_bxor(ctx, v2.0, v925, v926);
                                                                // Rule at src/opts/bitops.isle line 651.
                                                                returns.extend(Some(v927));
                                                                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 v642 = constructor_bnot(ctx, v2.0, v99.0);
                                                                                                // Rule at src/opts/bitops.isle line 284.
                                                                                                returns.extend(Some(v642));
                                                                                                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 v636,
                                                                                    arg: v637,
                                                                                } = &v259.1 {
                                                                                    if let &Opcode::Bnot = v636 {
                                                                                        if v99.1 == v637 {
                                                                                            if v2.0 == v259.0 {
                                                                                                let v642 = constructor_bnot(ctx, v2.0, v99.0);
                                                                                                // Rule at src/opts/bitops.isle line 283.
                                                                                                returns.extend(Some(v642));
                                                                                                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 v642 = constructor_bnot(ctx, v2.0, v99.0);
                                                                                                // Rule at src/opts/bitops.isle line 288.
                                                                                                returns.extend(Some(v642));
                                                                                                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 v639,
                                                                                    arg: v640,
                                                                                } = &v275.1 {
                                                                                    if let &Opcode::Bnot = v639 {
                                                                                        if v99.1 == v640 {
                                                                                            if v2.0 == v275.0 {
                                                                                                let v642 = constructor_bnot(ctx, v2.0, v99.0);
                                                                                                // Rule at src/opts/bitops.isle line 285.
                                                                                                returns.extend(Some(v642));
                                                                                                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 v672 = constructor_bnot(ctx, v2.0, v99.1);
                                                                                                // Rule at src/opts/bitops.isle line 286.
                                                                                                returns.extend(Some(v672));
                                                                                                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 v636,
                                                                                    arg: v637,
                                                                                } = &v259.1 {
                                                                                    if let &Opcode::Bnot = v636 {
                                                                                        if v99.0 == v637 {
                                                                                            if v2.0 == v259.0 {
                                                                                                let v672 = constructor_bnot(ctx, v2.0, v99.1);
                                                                                                // Rule at src/opts/bitops.isle line 287.
                                                                                                returns.extend(Some(v672));
                                                                                                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 v672 = constructor_bnot(ctx, v2.0, v99.1);
                                                                                                // Rule at src/opts/bitops.isle line 290.
                                                                                                returns.extend(Some(v672));
                                                                                                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 v639,
                                                                                    arg: v640,
                                                                                } = &v275.1 {
                                                                                    if let &Opcode::Bnot = v639 {
                                                                                        if v99.0 == v640 {
                                                                                            if v2.0 == v275.0 {
                                                                                                let v672 = constructor_bnot(ctx, v2.0, v99.1);
                                                                                                // Rule at src/opts/bitops.isle line 289.
                                                                                                returns.extend(Some(v672));
                                                                                                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 433.
                                                                                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 439.
                                                                                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 v636,
                                                                                    arg: v637,
                                                                                } = &v259.1 {
                                                                                    if let &Opcode::Bnot = v636 {
                                                                                        if v99.1 == v637 {
                                                                                            if v2.0 == v259.0 {
                                                                                                let v642 = constructor_bnot(ctx, v2.0, v99.0);
                                                                                                let v643 = constructor_bor(ctx, v2.0, v99.1, v642);
                                                                                                // Rule at src/opts/bitops.isle line 696.
                                                                                                returns.extend(Some(v643));
                                                                                                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 435.
                                                                                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 437.
                                                                                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 v639,
                                                                                    arg: v640,
                                                                                } = &v275.1 {
                                                                                    if let &Opcode::Bnot = v639 {
                                                                                        if v99.1 == v640 {
                                                                                            if v2.0 == v275.0 {
                                                                                                let v642 = constructor_bnot(ctx, v2.0, v99.0);
                                                                                                let v643 = constructor_bor(ctx, v2.0, v99.1, v642);
                                                                                                // Rule at src/opts/bitops.isle line 692.
                                                                                                returns.extend(Some(v643));
                                                                                                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 v636,
                                                                                    arg: v637,
                                                                                } = &v259.1 {
                                                                                    if let &Opcode::Bnot = v636 {
                                                                                        if v99.0 == v637 {
                                                                                            if v2.0 == v259.0 {
                                                                                                let v672 = constructor_bnot(ctx, v2.0, v99.1);
                                                                                                let v755 = constructor_bor(ctx, v2.0, v99.0, v672);
                                                                                                // Rule at src/opts/bitops.isle line 694.
                                                                                                returns.extend(Some(v755));
                                                                                                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 v639,
                                                                                    arg: v640,
                                                                                } = &v275.1 {
                                                                                    if let &Opcode::Bnot = v639 {
                                                                                        if v99.0 == v640 {
                                                                                            if v2.0 == v275.0 {
                                                                                                let v672 = constructor_bnot(ctx, v2.0, v99.1);
                                                                                                let v755 = constructor_bor(ctx, v2.0, v99.0, v672);
                                                                                                // Rule at src/opts/bitops.isle line 690.
                                                                                                returns.extend(Some(v755));
                                                                                                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 v753 = constructor_bnot(ctx, v2.0, v135.1);
                                                                        let v754 = constructor_bor(ctx, v2.0, v30, v753);
                                                                        // Rule at src/opts/bitops.isle line 333.
                                                                        returns.extend(Some(v754));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v30 == v135.1 {
                                                                        let v756 = constructor_bnot(ctx, v2.0, v135.0);
                                                                        let v757 = constructor_bor(ctx, v2.0, v30, v756);
                                                                        // Rule at src/opts/bitops.isle line 335.
                                                                        returns.extend(Some(v757));
                                                                        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 46.
                                                                            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 432.
                                                                            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 438.
                                                                            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 v642 = constructor_bnot(ctx, v2.0, v99.0);
                                                                                            let v896 = constructor_bor(ctx, v2.0, v114, v642);
                                                                                            // Rule at src/opts/bitops.isle line 695.
                                                                                            returns.extend(Some(v896));
                                                                                            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 434.
                                                                            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 436.
                                                                            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 v642 = constructor_bnot(ctx, v2.0, v99.0);
                                                                                            let v896 = constructor_bor(ctx, v2.0, v114, v642);
                                                                                            // Rule at src/opts/bitops.isle line 693.
                                                                                            returns.extend(Some(v896));
                                                                                            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 v672 = constructor_bnot(ctx, v2.0, v99.1);
                                                                                            let v894 = constructor_bor(ctx, v2.0, v107, v672);
                                                                                            // Rule at src/opts/bitops.isle line 689.
                                                                                            returns.extend(Some(v894));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                    if v107 == v135.1 {
                                                                                        if v99.1 == v135.0 {
                                                                                            let v672 = constructor_bnot(ctx, v2.0, v99.1);
                                                                                            let v894 = constructor_bor(ctx, v2.0, v107, v672);
                                                                                            // Rule at src/opts/bitops.isle line 691.
                                                                                            returns.extend(Some(v894));
                                                                                            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 v1148,
                                                                                        imm: v1149,
                                                                                    } = &v259.1 {
                                                                                        if let &Opcode::Iconst = v1148 {
                                                                                            let v1159 = constructor_bxor(ctx, v2.0, v99.0, v135.0);
                                                                                            let v1160 = constructor_bxor(ctx, v2.0, v99.1, v135.1);
                                                                                            let v1161 = constructor_bxor(ctx, v2.0, v1159, v1160);
                                                                                            // Rule at src/opts/cprop.isle line 348.
                                                                                            returns.extend(Some(v1161));
                                                                                            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 225.
                                                    returns.extend(Some(v135.0));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    // Rule at src/opts/bitops.isle line 501.
                                                    returns.extend(Some(v135.0));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.0 == v135.0 {
                                                    // Rule at src/opts/bitops.isle line 499.
                                                    returns.extend(Some(v135.1));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::IntCompare {
                                    opcode: ref v764,
                                    args: ref v765,
                                    cond: ref v766,
                                } => {
                                    if let &Opcode::Icmp = v764 {
                                        match v766 {
                                            &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 v758,
                                                            args: ref v759,
                                                            cond: ref v760,
                                                        } = &v19.1 {
                                                            if let &Opcode::Icmp = v758 {
                                                                match v760 {
                                                                    &IntCC::SignedGreaterThan => {
                                                                        if v2.0 == v19.0 {
                                                                            let v761 = C::unpack_value_array_2(ctx, v759);
                                                                            let v767 = C::unpack_value_array_2(ctx, v765);
                                                                            if v761.0 == v767.1 {
                                                                                if v761.1 == v767.0 {
                                                                                    let v770 = constructor_ne(ctx, v2.0, v761.0, v761.1);
                                                                                    // Rule at src/opts/icmp.isle line 309.
                                                                                    returns.extend(Some(v770));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedLessThan => {
                                                                        if v2.0 == v19.0 {
                                                                            let v761 = C::unpack_value_array_2(ctx, v759);
                                                                            let v767 = C::unpack_value_array_2(ctx, v765);
                                                                            if v761.0 == v767.0 {
                                                                                if v761.1 == v767.1 {
                                                                                    let v770 = constructor_ne(ctx, v2.0, v761.0, v761.1);
                                                                                    // Rule at src/opts/icmp.isle line 311.
                                                                                    returns.extend(Some(v770));
                                                                                    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 v758,
                                                            args: ref v759,
                                                            cond: ref v760,
                                                        } = &v19.1 {
                                                            if let &Opcode::Icmp = v758 {
                                                                match v760 {
                                                                    &IntCC::SignedGreaterThan => {
                                                                        if v2.0 == v19.0 {
                                                                            let v761 = C::unpack_value_array_2(ctx, v759);
                                                                            let v767 = C::unpack_value_array_2(ctx, v765);
                                                                            if v761.0 == v767.0 {
                                                                                if v761.1 == v767.1 {
                                                                                    let v770 = constructor_ne(ctx, v2.0, v761.0, v761.1);
                                                                                    // Rule at src/opts/icmp.isle line 310.
                                                                                    returns.extend(Some(v770));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedLessThan => {
                                                                        if v2.0 == v19.0 {
                                                                            let v761 = C::unpack_value_array_2(ctx, v759);
                                                                            let v767 = C::unpack_value_array_2(ctx, v765);
                                                                            if v761.0 == v767.1 {
                                                                                if v761.1 == v767.0 {
                                                                                    let v770 = constructor_ne(ctx, v2.0, v761.0, v761.1);
                                                                                    // Rule at src/opts/icmp.isle line 312.
                                                                                    returns.extend(Some(v770));
                                                                                    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 v758,
                                                            args: ref v759,
                                                            cond: ref v760,
                                                        } = &v19.1 {
                                                            if let &Opcode::Icmp = v758 {
                                                                match v760 {
                                                                    &IntCC::UnsignedGreaterThan => {
                                                                        if v2.0 == v19.0 {
                                                                            let v761 = C::unpack_value_array_2(ctx, v759);
                                                                            let v767 = C::unpack_value_array_2(ctx, v765);
                                                                            if v761.0 == v767.1 {
                                                                                if v761.1 == v767.0 {
                                                                                    let v770 = constructor_ne(ctx, v2.0, v761.0, v761.1);
                                                                                    // Rule at src/opts/icmp.isle line 313.
                                                                                    returns.extend(Some(v770));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        if v2.0 == v19.0 {
                                                                            let v761 = C::unpack_value_array_2(ctx, v759);
                                                                            let v767 = C::unpack_value_array_2(ctx, v765);
                                                                            if v761.0 == v767.0 {
                                                                                if v761.1 == v767.1 {
                                                                                    let v770 = constructor_ne(ctx, v2.0, v761.0, v761.1);
                                                                                    // Rule at src/opts/icmp.isle line 315.
                                                                                    returns.extend(Some(v770));
                                                                                    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 v758,
                                                            args: ref v759,
                                                            cond: ref v760,
                                                        } = &v19.1 {
                                                            if let &Opcode::Icmp = v758 {
                                                                match v760 {
                                                                    &IntCC::UnsignedGreaterThan => {
                                                                        if v2.0 == v19.0 {
                                                                            let v761 = C::unpack_value_array_2(ctx, v759);
                                                                            let v767 = C::unpack_value_array_2(ctx, v765);
                                                                            if v761.0 == v767.0 {
                                                                                if v761.1 == v767.1 {
                                                                                    let v770 = constructor_ne(ctx, v2.0, v761.0, v761.1);
                                                                                    // Rule at src/opts/icmp.isle line 314.
                                                                                    returns.extend(Some(v770));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        if v2.0 == v19.0 {
                                                                            let v761 = C::unpack_value_array_2(ctx, v759);
                                                                            let v767 = C::unpack_value_array_2(ctx, v765);
                                                                            if v761.0 == v767.1 {
                                                                                if v761.1 == v767.0 {
                                                                                    let v770 = constructor_ne(ctx, v2.0, v761.0, v761.1);
                                                                                    // Rule at src/opts/icmp.isle line 316.
                                                                                    returns.extend(Some(v770));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v26,
                                    arg: v27,
                                } => {
                                    match v26 {
                                        &Opcode::Splat => {
                                            let v2006 = C::ty_vector_not_float(ctx, v2.0);
                                            if let Some(v2007) = v2006 {
                                                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 v1869 = C::lane_type(ctx, v2.0);
                                                                    let v2012 = constructor_bxor(ctx, v1869, v30, v27);
                                                                    let v2013 = constructor_splat(ctx, v2.0, v2012);
                                                                    // Rule at src/opts/vector.isle line 22.
                                                                    returns.extend(Some(v2013));
                                                                    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 v634 = constructor_band(ctx, v2.0, v99.0, v114);
                                                                                        let v885 = constructor_bnot(ctx, v2.0, v634);
                                                                                        // Rule at src/opts/bitops.isle line 576.
                                                                                        returns.extend(Some(v885));
                                                                                        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 v635 = constructor_band(ctx, v2.0, v99.1, v107);
                                                                                        let v888 = constructor_bnot(ctx, v2.0, v635);
                                                                                        // Rule at src/opts/bitops.isle line 578.
                                                                                        returns.extend(Some(v888));
                                                                                        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 v672 = constructor_bnot(ctx, v2.0, v99.1);
                                                                        let v755 = constructor_bor(ctx, v2.0, v99.0, v672);
                                                                        // Rule at src/opts/bitops.isle line 334.
                                                                        returns.extend(Some(v755));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v27 == v99.1 {
                                                                        let v642 = constructor_bnot(ctx, v2.0, v99.0);
                                                                        let v643 = constructor_bor(ctx, v2.0, v99.1, v642);
                                                                        // Rule at src/opts/bitops.isle line 336.
                                                                        returns.extend(Some(v643));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                    }
                                                }
                                            }
                                            let v352 = C::ty_int_vec128(ctx, v2.0);
                                            if let Some(v353) = v352 {
                                                if v11.0 == v353 {
                                                    if v7.0 == v27 {
                                                        let v354 = constructor_iconst_s(ctx, v353, -1_i64);
                                                        let v355 = C::subsume(ctx, v354);
                                                        // Rule at src/opts/bitops.isle line 30.
                                                        returns.extend(Some(v355));
                                                        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 v1364 = C::value_type(ctx, v30);
                                                        let v1395 = C::value_type(ctx, v27);
                                                        if v1364 == v1395 {
                                                            let v1400 = constructor_bxor(ctx, v1364, v30, v27);
                                                            let v1401 = constructor_uextend(ctx, v2.0, v1400);
                                                            // Rule at src/opts/extends.isle line 74.
                                                            returns.extend(Some(v1401));
                                                            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 v1064 = constructor_bxor(ctx, v2.0, v99.1, v7.1);
                                                                            let v1065 = constructor_bxor(ctx, v2.0, v99.0, v1064);
                                                                            // Rule at src/opts/cprop.isle line 222.
                                                                            returns.extend(Some(v1065));
                                                                            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 v976 = C::imm64_xor(ctx, v335, v23, v15);
                                                                let v977 = constructor_iconst(ctx, v335, v976);
                                                                let v978 = C::subsume(ctx, v977);
                                                                // Rule at src/opts/cprop.isle line 67.
                                                                returns.extend(Some(v978));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        let v1625 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 21.
                                        returns.extend(Some(v1625));
                                        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 v875 = constructor_bor(ctx, v2.0, v107, v99.1);
                                                                    // Rule at src/opts/bitops.isle line 582.
                                                                    returns.extend(Some(v875));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                let v872 = constructor_band(ctx, v2.0, v107, v99.1);
                                                                let v923 = constructor_bxor(ctx, v2.0, v7.1, v99.1);
                                                                let v924 = constructor_bxor(ctx, v2.0, v872, v923);
                                                                // Rule at src/opts/bitops.isle line 650.
                                                                returns.extend(Some(v924));
                                                                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 v876 = constructor_bor(ctx, v2.0, v114, v99.0);
                                                                    // Rule at src/opts/bitops.isle line 584.
                                                                    returns.extend(Some(v876));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                let v874 = constructor_band(ctx, v2.0, v114, v99.0);
                                                                let v928 = constructor_bxor(ctx, v2.0, v7.1, v99.0);
                                                                let v929 = constructor_bxor(ctx, v2.0, v874, v928);
                                                                // Rule at src/opts/bitops.isle line 652.
                                                                returns.extend(Some(v929));
                                                                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 224.
                                                    returns.extend(Some(v99.0));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    // Rule at src/opts/bitops.isle line 500.
                                                    returns.extend(Some(v99.0));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.1 == v99.0 {
                                                    // Rule at src/opts/bitops.isle line 498.
                                                    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 v352 = C::ty_int_vec128(ctx, v2.0);
                                            if let Some(v353) = v352 {
                                                if v19.0 == v353 {
                                                    let v354 = constructor_iconst_s(ctx, v353, -1_i64);
                                                    let v355 = C::subsume(ctx, v354);
                                                    // Rule at src/opts/bitops.isle line 31.
                                                    returns.extend(Some(v355));
                                                    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 v1034 = constructor_bxor(ctx, v2.0, v7.1, v7.0);
                                            // Rule at src/opts/cprop.isle line 164.
                                            returns.extend(Some(v1034));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        let v1625 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 19.
                                        returns.extend(Some(v1625));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                _ => {}
                            }
                        }
                        if v7.0 == v7.1 {
                            let v350 = constructor_all_zero(ctx, v2.0);
                            let v351 = C::subsume(ctx, v350);
                            // Rule at src/opts/bitops.isle line 25.
                            returns.extend(Some(v351));
                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                        }
                        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 v366 = constructor_bnot(ctx, v2.0, v7.0);
                                        // Rule at src/opts/bitops.isle line 80.
                                        returns.extend(Some(v366));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                            }
                        }
                    }
                    &Opcode::Rotl => {
                        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::Rotl => {
                                            if v2.0 == v19.0 {
                                                let v99 = C::unpack_value_array_2(ctx, v98);
                                                let v1884 = C::value_type(ctx, v99.1);
                                                let v1885 = C::value_type(ctx, v7.1);
                                                if v1884 == v1885 {
                                                    let v1878 = constructor_iadd_uextend(ctx, v99.1, v7.1);
                                                    let v1879 = constructor_rotl(ctx, v2.0, v99.0, v1878);
                                                    // Rule at src/opts/shifts.isle line 260.
                                                    returns.extend(Some(v1879));
                                                    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::UnaryImm {
                                                        opcode: ref v14,
                                                        imm: v15,
                                                    } = &v11.1 {
                                                        if let &Opcode::Iconst = v14 {
                                                            let v1878 = constructor_iadd_uextend(ctx, v99.1, v7.1);
                                                            let v1879 = constructor_rotl(ctx, v2.0, v99.0, v1878);
                                                            // Rule at src/opts/shifts.isle line 239.
                                                            returns.extend(Some(v1879));
                                                            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 v1878 = constructor_iadd_uextend(ctx, v99.1, v7.1);
                                                            let v1879 = constructor_rotl(ctx, v2.0, v99.0, v1878);
                                                            // Rule at src/opts/shifts.isle line 238.
                                                            returns.extend(Some(v1879));
                                                            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 v1877 = C::subsume(ctx, v99.0);
                                                    // Rule at src/opts/shifts.isle line 203.
                                                    returns.extend(Some(v1877));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let v1884 = C::value_type(ctx, v99.1);
                                                let v1885 = C::value_type(ctx, v7.1);
                                                if v1884 == v1885 {
                                                    let v1881 = constructor_isub_uextend(ctx, v99.1, v7.1);
                                                    let v1883 = constructor_rotr(ctx, v2.0, v99.0, v1881);
                                                    // Rule at src/opts/shifts.isle line 265.
                                                    returns.extend(Some(v1883));
                                                    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::UnaryImm {
                                                        opcode: ref v14,
                                                        imm: v15,
                                                    } = &v11.1 {
                                                        if let &Opcode::Iconst = v14 {
                                                            let v1881 = constructor_isub_uextend(ctx, v99.1, v7.1);
                                                            let v1883 = constructor_rotr(ctx, v2.0, v99.0, v1881);
                                                            // Rule at src/opts/shifts.isle line 246.
                                                            returns.extend(Some(v1883));
                                                            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 v1881 = constructor_isub_uextend(ctx, v99.1, v7.1);
                                                            let v1883 = constructor_rotr(ctx, v2.0, v99.0, v1881);
                                                            // Rule at src/opts/shifts.isle line 245.
                                                            returns.extend(Some(v1883));
                                                            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 v1869 = C::lane_type(ctx, v2.0);
                                            let v2040 = constructor_rotl(ctx, v1869, v30, v7.1);
                                            let v2041 = constructor_splat(ctx, v2.0, v2040);
                                            // Rule at src/opts/vector.isle line 68.
                                            returns.extend(Some(v2041));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v22,
                                    imm: v23,
                                } => {
                                    if let &Opcode::Iconst = v22 {
                                        let v24 = C::u64_from_imm64(ctx, v23);
                                        if v24 == 0x0_u64 {
                                            if v2.0 == v19.0 {
                                                let v53 = constructor_iconst_u(ctx, v2.0, 0x0_u64);
                                                let v54 = C::subsume(ctx, v53);
                                                // Rule at src/opts/shifts.isle line 322.
                                                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 {
                                            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 {
                                                            let v994 = C::imm64_rotl(ctx, v335, v23, v15);
                                                            let v995 = constructor_iconst(ctx, v335, v994);
                                                            let v996 = C::subsume(ctx, v995);
                                                            // Rule at src/opts/cprop.isle line 98.
                                                            returns.extend(Some(v996));
                                                            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::Iconcat = v133 {
                                        let v135 = C::unpack_value_array_2(ctx, v134);
                                        let v1865 = constructor_rotl(ctx, v2.0, v7.0, v135.0);
                                        // Rule at src/opts/shifts.isle line 142.
                                        returns.extend(Some(v1865));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v26,
                                    arg: v27,
                                } => {
                                    match v26 {
                                        &Opcode::Ireduce => {
                                            let v1395 = C::value_type(ctx, v27);
                                            let v1854 = C::fits_in_64(ctx, v1395);
                                            if let Some(v1855) = v1854 {
                                                let v1860 = constructor_rotl(ctx, v2.0, v7.0, v27);
                                                // Rule at src/opts/shifts.isle line 126.
                                                returns.extend(Some(v1860));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        &Opcode::Uextend => {
                                            let v1860 = constructor_rotl(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 127.
                                            returns.extend(Some(v1860));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Sextend => {
                                            let v1860 = constructor_rotl(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 128.
                                            returns.extend(Some(v1860));
                                            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/shifts.isle line 19.
                                                returns.extend(Some(v17));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        let v367 = constructor_ty_shift_mask(ctx, v2.0);
                                        let v1867 = C::u64_and(ctx, v16, v367);
                                        let v1917 = C::u64_eq(ctx, v16, v1867);
                                        if v1917 == false {
                                            let v1918 = constructor_iconst_u(ctx, v11.0, v1867);
                                            let v1923 = constructor_rotl(ctx, v2.0, v7.0, v1918);
                                            // Rule at src/opts/shifts.isle line 308.
                                            returns.extend(Some(v1923));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                        let mut v343 = C::inst_data_value_tupled_etor_returns::default();
                        C::inst_data_value_tupled_etor(ctx, v7.0, &mut v343);
                        let mut v343 = v343.into_context_iter();
                        while let Some(v344) = v343.next(ctx) {
                            let v345 = C::iconst_sextend_etor(ctx, v344);
                            if let Some(v346) = v345 {
                                if v346.1 == -1_i64 {
                                    if v2.0 == v346.0 {
                                        let v244 = constructor_iconst_s(ctx, v2.0, -1_i64);
                                        let v1929 = C::subsume(ctx, v244);
                                        // Rule at src/opts/shifts.isle line 327.
                                        returns.extend(Some(v1929));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                            }
                        }
                    }
                    &Opcode::Rotr => {
                        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::Rotl => {
                                            if v2.0 == v19.0 {
                                                let v99 = C::unpack_value_array_2(ctx, v98);
                                                if v7.1 == v99.1 {
                                                    let v1877 = C::subsume(ctx, v99.0);
                                                    // Rule at src/opts/shifts.isle line 204.
                                                    returns.extend(Some(v1877));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let v1884 = C::value_type(ctx, v99.1);
                                                let v1885 = C::value_type(ctx, v7.1);
                                                if v1884 == v1885 {
                                                    let v1881 = constructor_isub_uextend(ctx, v99.1, v7.1);
                                                    let v1882 = constructor_rotl(ctx, v2.0, v99.0, v1881);
                                                    // Rule at src/opts/shifts.isle line 263.
                                                    returns.extend(Some(v1882));
                                                    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::UnaryImm {
                                                        opcode: ref v14,
                                                        imm: v15,
                                                    } = &v11.1 {
                                                        if let &Opcode::Iconst = v14 {
                                                            let v1881 = constructor_isub_uextend(ctx, v99.1, v7.1);
                                                            let v1882 = constructor_rotl(ctx, v2.0, v99.0, v1881);
                                                            // Rule at src/opts/shifts.isle line 244.
                                                            returns.extend(Some(v1882));
                                                            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 v1881 = constructor_isub_uextend(ctx, v99.1, v7.1);
                                                            let v1882 = constructor_rotl(ctx, v2.0, v99.0, v1881);
                                                            // Rule at src/opts/shifts.isle line 243.
                                                            returns.extend(Some(v1882));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Rotr => {
                                            if v2.0 == v19.0 {
                                                let v99 = C::unpack_value_array_2(ctx, v98);
                                                let v1884 = C::value_type(ctx, v99.1);
                                                let v1885 = C::value_type(ctx, v7.1);
                                                if v1884 == v1885 {
                                                    let v1878 = constructor_iadd_uextend(ctx, v99.1, v7.1);
                                                    let v1880 = constructor_rotr(ctx, v2.0, v99.0, v1878);
                                                    // Rule at src/opts/shifts.isle line 258.
                                                    returns.extend(Some(v1880));
                                                    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::UnaryImm {
                                                        opcode: ref v14,
                                                        imm: v15,
                                                    } = &v11.1 {
                                                        if let &Opcode::Iconst = v14 {
                                                            let v1878 = constructor_iadd_uextend(ctx, v99.1, v7.1);
                                                            let v1880 = constructor_rotr(ctx, v2.0, v99.0, v1878);
                                                            // Rule at src/opts/shifts.isle line 241.
                                                            returns.extend(Some(v1880));
                                                            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 v1878 = constructor_iadd_uextend(ctx, v99.1, v7.1);
                                                            let v1880 = constructor_rotr(ctx, v2.0, v99.0, v1878);
                                                            // Rule at src/opts/shifts.isle line 240.
                                                            returns.extend(Some(v1880));
                                                            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 v1869 = C::lane_type(ctx, v2.0);
                                            let v2042 = constructor_rotr(ctx, v1869, v30, v7.1);
                                            let v2043 = constructor_splat(ctx, v2.0, v2042);
                                            // Rule at src/opts/vector.isle line 71.
                                            returns.extend(Some(v2043));
                                            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 v53 = constructor_iconst_u(ctx, v2.0, 0x0_u64);
                                                let v54 = C::subsume(ctx, v53);
                                                // Rule at src/opts/shifts.isle line 323.
                                                returns.extend(Some(v54));
                                                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::Ternary {
                                                    opcode: ref v1886,
                                                    args: ref v1887,
                                                } = &v11.1 {
                                                    if let &Opcode::Select = v1886 {
                                                        if v2.0 == v11.0 {
                                                            let v1888 = C::unpack_value_array_3(ctx, v1887);
                                                            let mut v1892 = C::inst_data_value_etor_returns::default();
                                                            C::inst_data_value_etor(ctx, v1888.1, &mut v1892);
                                                            let mut v1892 = v1892.into_context_iter();
                                                            while let Some(v1893) = v1892.next(ctx) {
                                                                if let &InstructionData::UnaryImm {
                                                                    opcode: ref v1896,
                                                                    imm: v1897,
                                                                } = &v1893.1 {
                                                                    if let &Opcode::Iconst = v1896 {
                                                                        if v2.0 == v1893.0 {
                                                                            let mut v1898 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v1888.2, &mut v1898);
                                                                            let mut v1898 = v1898.into_context_iter();
                                                                            while let Some(v1899) = v1898.next(ctx) {
                                                                                if let &InstructionData::UnaryImm {
                                                                                    opcode: ref v1902,
                                                                                    imm: v1903,
                                                                                } = &v1899.1 {
                                                                                    if let &Opcode::Iconst = v1902 {
                                                                                        if v2.0 == v1899.0 {
                                                                                            let v1904 = C::imm64_rotr(ctx, v2.0, v23, v1897);
                                                                                            let v1905 = constructor_iconst(ctx, v2.0, v1904);
                                                                                            let v1906 = C::imm64_rotr(ctx, v2.0, v23, v1903);
                                                                                            let v1907 = constructor_iconst(ctx, v2.0, v1906);
                                                                                            let v1908 = constructor_select(ctx, v2.0, v1888.0, v1905, v1907);
                                                                                            // Rule at src/opts/shifts.isle line 269.
                                                                                            returns.extend(Some(v1908));
                                                                                            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 {
                                                            let v991 = C::imm64_rotr(ctx, v335, v23, v15);
                                                            let v992 = constructor_iconst(ctx, v335, v991);
                                                            let v993 = C::subsume(ctx, v992);
                                                            // Rule at src/opts/cprop.isle line 93.
                                                            returns.extend(Some(v993));
                                                            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::Iconcat = v133 {
                                        let v135 = C::unpack_value_array_2(ctx, v134);
                                        let v1864 = constructor_rotr(ctx, v2.0, v7.0, v135.0);
                                        // Rule at src/opts/shifts.isle line 141.
                                        returns.extend(Some(v1864));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v26,
                                    arg: v27,
                                } => {
                                    match v26 {
                                        &Opcode::Ireduce => {
                                            let v1395 = C::value_type(ctx, v27);
                                            let v1854 = C::fits_in_64(ctx, v1395);
                                            if let Some(v1855) = v1854 {
                                                let v1859 = constructor_rotr(ctx, v2.0, v7.0, v27);
                                                // Rule at src/opts/shifts.isle line 123.
                                                returns.extend(Some(v1859));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        &Opcode::Uextend => {
                                            let v1859 = constructor_rotr(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 124.
                                            returns.extend(Some(v1859));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Sextend => {
                                            let v1859 = constructor_rotr(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 125.
                                            returns.extend(Some(v1859));
                                            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/shifts.isle line 15.
                                                returns.extend(Some(v17));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        let v367 = constructor_ty_shift_mask(ctx, v2.0);
                                        let v1867 = C::u64_and(ctx, v16, v367);
                                        let v1917 = C::u64_eq(ctx, v16, v1867);
                                        if v1917 == false {
                                            let v1918 = constructor_iconst_u(ctx, v11.0, v1867);
                                            let v1922 = constructor_rotr(ctx, v2.0, v7.0, v1918);
                                            // Rule at src/opts/shifts.isle line 305.
                                            returns.extend(Some(v1922));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                        let mut v343 = C::inst_data_value_tupled_etor_returns::default();
                        C::inst_data_value_tupled_etor(ctx, v7.0, &mut v343);
                        let mut v343 = v343.into_context_iter();
                        while let Some(v344) = v343.next(ctx) {
                            let v345 = C::iconst_sextend_etor(ctx, v344);
                            if let Some(v346) = v345 {
                                if v346.1 == -1_i64 {
                                    if v2.0 == v346.0 {
                                        let v244 = constructor_iconst_s(ctx, v2.0, -1_i64);
                                        let v1929 = C::subsume(ctx, v244);
                                        // Rule at src/opts/shifts.isle line 328.
                                        returns.extend(Some(v1929));
                                        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 v1861 = constructor_ishl(ctx, v2.0, v7.0, v135.0);
                                        // Rule at src/opts/shifts.isle line 138.
                                        returns.extend(Some(v1861));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v26,
                                    arg: v27,
                                } => {
                                    match v26 {
                                        &Opcode::Ireduce => {
                                            let v1395 = C::value_type(ctx, v27);
                                            let v1854 = C::fits_in_64(ctx, v1395);
                                            if let Some(v1855) = v1854 {
                                                let v1856 = constructor_ishl(ctx, v2.0, v7.0, v27);
                                                // Rule at src/opts/shifts.isle line 114.
                                                returns.extend(Some(v1856));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        &Opcode::Uextend => {
                                            let v1856 = constructor_ishl(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 115.
                                            returns.extend(Some(v1856));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Sextend => {
                                            let v1856 = constructor_ishl(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 116.
                                            returns.extend(Some(v1856));
                                            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 v360 = C::u64_from_imm64(ctx, v128);
                                                                            let v367 = constructor_ty_shift_mask(ctx, v2.0);
                                                                            let v1866 = C::u64_and(ctx, v360, v367);
                                                                            let v16 = C::u64_from_imm64(ctx, v15);
                                                                            let v1867 = C::u64_and(ctx, v16, v367);
                                                                            let v1868 = C::u64_wrapping_add(ctx, v1866, v1867);
                                                                            let v1869 = C::lane_type(ctx, v2.0);
                                                                            let v1870 = C::ty_bits_u64(ctx, v1869);
                                                                            let v1871 = C::u64_lt(ctx, v1868, v1870);
                                                                            if v1871 == true {
                                                                                let v1872 = constructor_iconst_u(ctx, v110.0, v1868);
                                                                                let v1873 = constructor_ishl(ctx, v2.0, v99.0, v1872);
                                                                                // Rule at src/opts/shifts.isle line 151.
                                                                                returns.extend(Some(v1873));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                            let v1835 = C::ty_bits_u64(ctx, v2.0);
                                                                            let v1876 = C::u64_lt_eq(ctx, v1835, v1868);
                                                                            if v1876 == 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 v1046,
                                                                        imm: v1047,
                                                                    } = &v103.1 {
                                                                        if let &Opcode::Iconst = v1046 {
                                                                            let v1142 = constructor_ishl(ctx, v2.0, v99.0, v7.1);
                                                                            let v1143 = constructor_ishl(ctx, v2.0, v1142, v99.1);
                                                                            // Rule at src/opts/cprop.isle line 319.
                                                                            returns.extend(Some(v1143));
                                                                            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 v1826 = C::imm64(ctx, 0xffffffffffffffff_u64);
                                                                                    let v1827 = C::imm64_shl(ctx, v335, v1826, v128);
                                                                                    let v1828 = constructor_iconst(ctx, v335, v1827);
                                                                                    let v1829 = constructor_band(ctx, v335, v99.0, v1828);
                                                                                    // Rule at src/opts/shifts.isle line 26.
                                                                                    returns.extend(Some(v1829));
                                                                                    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 v1826 = C::imm64(ctx, 0xffffffffffffffff_u64);
                                                                                    let v1827 = C::imm64_shl(ctx, v335, v1826, v128);
                                                                                    let v1828 = constructor_iconst(ctx, v335, v1827);
                                                                                    let v1829 = constructor_band(ctx, v335, v99.0, v1828);
                                                                                    // Rule at src/opts/shifts.isle line 31.
                                                                                    returns.extend(Some(v1829));
                                                                                    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_shl(ctx, v335, v23, v15);
                                                                let v983 = constructor_iconst(ctx, v335, v982);
                                                                let v984 = C::subsume(ctx, v983);
                                                                // Rule at src/opts/cprop.isle line 78.
                                                                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 3.
                                                returns.extend(Some(v17));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        let v367 = constructor_ty_shift_mask(ctx, v2.0);
                                        let v1867 = C::u64_and(ctx, v16, v367);
                                        let v1917 = C::u64_eq(ctx, v16, v1867);
                                        if v1917 == false {
                                            let v1918 = constructor_iconst_u(ctx, v11.0, v1867);
                                            let v1919 = constructor_ishl(ctx, v2.0, v7.0, v1918);
                                            // Rule at src/opts/shifts.isle line 296.
                                            returns.extend(Some(v1919));
                                            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::Unary {
                                    opcode: ref v29,
                                    arg: v30,
                                } => {
                                    if let &Opcode::Splat = v29 {
                                        if v2.0 == v19.0 {
                                            let v1869 = C::lane_type(ctx, v2.0);
                                            let v2044 = constructor_ishl(ctx, v1869, v30, v7.1);
                                            let v2045 = constructor_splat(ctx, v2.0, v2044);
                                            // Rule at src/opts/vector.isle line 74.
                                            returns.extend(Some(v2045));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v22,
                                    imm: v23,
                                } => {
                                    if let &Opcode::Iconst = v22 {
                                        let v24 = C::u64_from_imm64(ctx, v23);
                                        if v24 == 0x0_u64 {
                                            if v2.0 == v19.0 {
                                                let v53 = constructor_iconst_u(ctx, v2.0, 0x0_u64);
                                                let v54 = C::subsume(ctx, v53);
                                                // Rule at src/opts/shifts.isle line 319.
                                                returns.extend(Some(v54));
                                                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 v1862 = constructor_ushr(ctx, v2.0, v7.0, v135.0);
                                        // Rule at src/opts/shifts.isle line 139.
                                        returns.extend(Some(v1862));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v26,
                                    arg: v27,
                                } => {
                                    match v26 {
                                        &Opcode::Ireduce => {
                                            let v1395 = C::value_type(ctx, v27);
                                            let v1854 = C::fits_in_64(ctx, v1395);
                                            if let Some(v1855) = v1854 {
                                                let v1857 = constructor_ushr(ctx, v2.0, v7.0, v27);
                                                // Rule at src/opts/shifts.isle line 117.
                                                returns.extend(Some(v1857));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        &Opcode::Uextend => {
                                            let v1857 = constructor_ushr(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 118.
                                            returns.extend(Some(v1857));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Sextend => {
                                            let v1857 = constructor_ushr(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 119.
                                            returns.extend(Some(v1857));
                                            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 v1471 = C::ty_int(ctx, v335);
                                                                                if let Some(v1472) = v1471 {
                                                                                    if v19.0 == v1472 {
                                                                                        let v1830 = C::ty_mask(ctx, v1472);
                                                                                        let v1831 = C::imm64(ctx, v1830);
                                                                                        let v1832 = C::imm64_ushr(ctx, v1472, v1831, v128);
                                                                                        let v1833 = constructor_iconst(ctx, v1472, v1832);
                                                                                        let v1834 = constructor_band(ctx, v1472, v99.0, v1833);
                                                                                        // Rule at src/opts/shifts.isle line 40.
                                                                                        returns.extend(Some(v1834));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                            let v1386 = C::ty_int(ctx, v2.0);
                                                                            if let Some(v1387) = v1386 {
                                                                                let v360 = C::u64_from_imm64(ctx, v128);
                                                                                let v1841 = C::u64_matches_non_zero(ctx, v360);
                                                                                if let Some(v1842) = v1841 {
                                                                                    if v1842 == true {
                                                                                        let v1843 = C::ty_bits(ctx, v1387);
                                                                                        let v1844 = C::u8_into_u64(ctx, v1843);
                                                                                        let v1845 = C::u64_wrapping_sub(ctx, v1844, v360);
                                                                                        let v1846 = constructor_shift_amt_to_type(ctx, v1845);
                                                                                        if let Some(v1847) = v1846 {
                                                                                            if v19.0 == v1387 {
                                                                                                let v1848 = constructor_ireduce(ctx, v1847, v99.0);
                                                                                                let v1850 = constructor_uextend(ctx, v1387, v1848);
                                                                                                // Rule at src/opts/shifts.isle line 87.
                                                                                                returns.extend(Some(v1850));
                                                                                                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 v360 = C::u64_from_imm64(ctx, v128);
                                                                            let v367 = constructor_ty_shift_mask(ctx, v2.0);
                                                                            let v1866 = C::u64_and(ctx, v360, v367);
                                                                            let v16 = C::u64_from_imm64(ctx, v15);
                                                                            let v1867 = C::u64_and(ctx, v16, v367);
                                                                            let v1868 = C::u64_wrapping_add(ctx, v1866, v1867);
                                                                            let v1869 = C::lane_type(ctx, v2.0);
                                                                            let v1870 = C::ty_bits_u64(ctx, v1869);
                                                                            let v1871 = C::u64_lt(ctx, v1868, v1870);
                                                                            if v1871 == true {
                                                                                let v1872 = constructor_iconst_u(ctx, v110.0, v1868);
                                                                                let v1874 = constructor_ushr(ctx, v2.0, v99.0, v1872);
                                                                                // Rule at src/opts/shifts.isle line 160.
                                                                                returns.extend(Some(v1874));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                            let v1835 = C::ty_bits_u64(ctx, v2.0);
                                                                            let v1876 = C::u64_lt_eq(ctx, v1835, v1868);
                                                                            if v1876 == 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 v1046,
                                                                        imm: v1047,
                                                                    } = &v103.1 {
                                                                        if let &Opcode::Iconst = v1046 {
                                                                            let v1144 = constructor_ushr(ctx, v2.0, v99.0, v7.1);
                                                                            let v1145 = constructor_ushr(ctx, v2.0, v1144, v99.1);
                                                                            // Rule at src/opts/cprop.isle line 321.
                                                                            returns.extend(Some(v1145));
                                                                            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_ushr(ctx, v335, v23, v15);
                                                                let v986 = constructor_iconst(ctx, v335, v985);
                                                                let v987 = C::subsume(ctx, v986);
                                                                // Rule at src/opts/cprop.isle line 83.
                                                                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 7.
                                                returns.extend(Some(v17));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        let v367 = constructor_ty_shift_mask(ctx, v2.0);
                                        let v1867 = C::u64_and(ctx, v16, v367);
                                        let v1917 = C::u64_eq(ctx, v16, v1867);
                                        if v1917 == false {
                                            let v1918 = constructor_iconst_u(ctx, v11.0, v1867);
                                            let v1920 = constructor_ushr(ctx, v2.0, v7.0, v1918);
                                            // Rule at src/opts/shifts.isle line 299.
                                            returns.extend(Some(v1920));
                                            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 v1927 = constructor_ushr(ctx, v2.0, v99.1, v286.1);
                                                                let v1928 = constructor_band(ctx, v2.0, v286.0, v1927);
                                                                // Rule at src/opts/shifts.isle line 316.
                                                                returns.extend(Some(v1928));
                                                                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 v1869 = C::lane_type(ctx, v2.0);
                                            let v2046 = constructor_ushr(ctx, v1869, v30, v7.1);
                                            let v2047 = constructor_splat(ctx, v2.0, v2046);
                                            // Rule at src/opts/vector.isle line 77.
                                            returns.extend(Some(v2047));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v22,
                                    imm: v23,
                                } => {
                                    if let &Opcode::Iconst = v22 {
                                        let v24 = C::u64_from_imm64(ctx, v23);
                                        if v24 == 0x0_u64 {
                                            if v2.0 == v19.0 {
                                                let v53 = constructor_iconst_u(ctx, v2.0, 0x0_u64);
                                                let v54 = C::subsume(ctx, v53);
                                                // Rule at src/opts/shifts.isle line 320.
                                                returns.extend(Some(v54));
                                                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 v1863 = constructor_sshr(ctx, v2.0, v7.0, v135.0);
                                        // Rule at src/opts/shifts.isle line 140.
                                        returns.extend(Some(v1863));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v26,
                                    arg: v27,
                                } => {
                                    match v26 {
                                        &Opcode::Ireduce => {
                                            let v1395 = C::value_type(ctx, v27);
                                            let v1854 = C::fits_in_64(ctx, v1395);
                                            if let Some(v1855) = v1854 {
                                                let v1858 = constructor_sshr(ctx, v2.0, v7.0, v27);
                                                // Rule at src/opts/shifts.isle line 120.
                                                returns.extend(Some(v1858));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        &Opcode::Uextend => {
                                            let v1858 = constructor_sshr(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 121.
                                            returns.extend(Some(v1858));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Sextend => {
                                            let v1858 = constructor_sshr(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 122.
                                            returns.extend(Some(v1858));
                                            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 v367 = constructor_ty_shift_mask(ctx, v2.0);
                                                            let v368 = C::u64_eq(ctx, v16, v367);
                                                            if v368 == 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 v370 = constructor_bmask(ctx, v2.0, v107);
                                                                                            // Rule at src/opts/bitops.isle line 91.
                                                                                            returns.extend(Some(v370));
                                                                                            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 v369 = constructor_bmask(ctx, v2.0, v99.0);
                                                                                            // Rule at src/opts/bitops.isle line 87.
                                                                                            returns.extend(Some(v369));
                                                                                            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 v360 = C::u64_from_imm64(ctx, v128);
                                                                            if v16 == v360 {
                                                                                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 v1835 = C::ty_bits_u64(ctx, v2.0);
                                                                                                    let v108 = C::value_type(ctx, v107);
                                                                                                    let v119 = C::ty_bits_u64(ctx, v108);
                                                                                                    let v1836 = C::u64_wrapping_sub(ctx, v1835, v119);
                                                                                                    let v1837 = C::u64_eq(ctx, v360, v1836);
                                                                                                    if v1837 == true {
                                                                                                        let v1838 = constructor_sextend(ctx, v2.0, v107);
                                                                                                        // Rule at src/opts/shifts.isle line 49.
                                                                                                        returns.extend(Some(v1838));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                    let v1839 = C::u64_lt(ctx, v360, v1836);
                                                                                                    if v1839 == true {
                                                                                                        // Rule at src/opts/shifts.isle line 60.
                                                                                                        returns.extend(Some(v99.0));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                            &Opcode::Sextend => {
                                                                                                let v1835 = C::ty_bits_u64(ctx, v2.0);
                                                                                                let v108 = C::value_type(ctx, v107);
                                                                                                let v119 = C::ty_bits_u64(ctx, v108);
                                                                                                let v1836 = C::u64_wrapping_sub(ctx, v1835, v119);
                                                                                                let v1840 = C::u64_lt_eq(ctx, v360, v1836);
                                                                                                if v1840 == 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 v1386 = C::ty_int(ctx, v2.0);
                                                                            if let Some(v1387) = v1386 {
                                                                                if v19.0 == v1387 {
                                                                                    let v360 = C::u64_from_imm64(ctx, v128);
                                                                                    let v1841 = C::u64_matches_non_zero(ctx, v360);
                                                                                    if let Some(v1842) = v1841 {
                                                                                        if v1842 == true {
                                                                                            let v1843 = C::ty_bits(ctx, v1387);
                                                                                            let v1844 = C::u8_into_u64(ctx, v1843);
                                                                                            let v1845 = C::u64_wrapping_sub(ctx, v1844, v360);
                                                                                            let v1846 = constructor_shift_amt_to_type(ctx, v1845);
                                                                                            if let Some(v1847) = v1846 {
                                                                                                let v1848 = constructor_ireduce(ctx, v1847, v99.0);
                                                                                                let v1849 = constructor_sextend(ctx, v1387, v1848);
                                                                                                // Rule at src/opts/shifts.isle line 83.
                                                                                                returns.extend(Some(v1849));
                                                                                                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 v1046,
                                                                        imm: v1047,
                                                                    } = &v103.1 {
                                                                        if let &Opcode::Iconst = v1046 {
                                                                            let v1146 = constructor_sshr(ctx, v2.0, v99.0, v7.1);
                                                                            let v1147 = constructor_sshr(ctx, v2.0, v1146, v99.1);
                                                                            // Rule at src/opts/cprop.isle line 323.
                                                                            returns.extend(Some(v1147));
                                                                            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 v360 = C::u64_from_imm64(ctx, v128);
                                                                            let v367 = constructor_ty_shift_mask(ctx, v2.0);
                                                                            let v1866 = C::u64_and(ctx, v360, v367);
                                                                            let v16 = C::u64_from_imm64(ctx, v15);
                                                                            let v1867 = C::u64_and(ctx, v16, v367);
                                                                            let v1868 = C::u64_wrapping_add(ctx, v1866, v1867);
                                                                            let v1869 = C::lane_type(ctx, v2.0);
                                                                            let v1870 = C::ty_bits_u64(ctx, v1869);
                                                                            let v1871 = C::u64_lt(ctx, v1868, v1870);
                                                                            if v1871 == true {
                                                                                let v1872 = constructor_iconst_u(ctx, v110.0, v1868);
                                                                                let v1875 = constructor_sshr(ctx, v2.0, v99.0, v1872);
                                                                                // Rule at src/opts/shifts.isle line 169.
                                                                                returns.extend(Some(v1875));
                                                                                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 v988 = C::imm64_sshr(ctx, v335, v23, v15);
                                                                let v989 = constructor_iconst(ctx, v335, v988);
                                                                let v990 = C::subsume(ctx, v989);
                                                                // Rule at src/opts/cprop.isle line 88.
                                                                returns.extend(Some(v990));
                                                                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 v367 = constructor_ty_shift_mask(ctx, v2.0);
                                        let v1867 = C::u64_and(ctx, v16, v367);
                                        let v1917 = C::u64_eq(ctx, v16, v1867);
                                        if v1917 == false {
                                            let v1918 = constructor_iconst_u(ctx, v11.0, v1867);
                                            let v1921 = constructor_sshr(ctx, v2.0, v7.0, v1918);
                                            // Rule at src/opts/shifts.isle line 302.
                                            returns.extend(Some(v1921));
                                            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::Unary {
                                    opcode: ref v29,
                                    arg: v30,
                                } => {
                                    if let &Opcode::Splat = v29 {
                                        if v2.0 == v19.0 {
                                            let v1869 = C::lane_type(ctx, v2.0);
                                            let v2048 = constructor_sshr(ctx, v1869, v30, v7.1);
                                            let v2049 = constructor_splat(ctx, v2.0, v2048);
                                            // Rule at src/opts/vector.isle line 80.
                                            returns.extend(Some(v2049));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v22,
                                    imm: v23,
                                } => {
                                    if let &Opcode::Iconst = v22 {
                                        let v24 = C::u64_from_imm64(ctx, v23);
                                        if v24 == 0x0_u64 {
                                            if v2.0 == v19.0 {
                                                let v53 = constructor_iconst_u(ctx, v2.0, 0x0_u64);
                                                let v54 = C::subsume(ctx, v53);
                                                // Rule at src/opts/shifts.isle line 321.
                                                returns.extend(Some(v54));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                        let mut v343 = C::inst_data_value_tupled_etor_returns::default();
                        C::inst_data_value_tupled_etor(ctx, v7.0, &mut v343);
                        let mut v343 = v343.into_context_iter();
                        while let Some(v344) = v343.next(ctx) {
                            let v345 = C::iconst_sextend_etor(ctx, v344);
                            if let Some(v346) = v345 {
                                if v346.1 == -1_i64 {
                                    if v2.0 == v346.0 {
                                        let v244 = constructor_iconst_s(ctx, v2.0, -1_i64);
                                        let v1929 = C::subsume(ctx, v244);
                                        // Rule at src/opts/shifts.isle line 326.
                                        returns.extend(Some(v1929));
                                        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 v1186,
                                            imm: v1187,
                                        } = &v11.1 {
                                            if let &Opcode::F32const = v1186 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                C::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 v1184,
                                                            imm: v1185,
                                                        } = &v19.1 {
                                                            if let &Opcode::F32const = v1184 {
                                                                let v1188 = C::f32_add(ctx, v1185, v1187);
                                                                if let Some(v1189) = v1188 {
                                                                    let v1190 = constructor_f32const(ctx, F32, v1189);
                                                                    let v1191 = C::subsume(ctx, v1190);
                                                                    // Rule at src/opts/cprop.isle line 397.
                                                                    returns.extend(Some(v1191));
                                                                    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 v1194,
                                            imm: v1195,
                                        } = &v11.1 {
                                            if let &Opcode::F64const = v1194 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                C::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 v1192,
                                                            imm: v1193,
                                                        } = &v19.1 {
                                                            if let &Opcode::F64const = v1192 {
                                                                let v1196 = C::f64_add(ctx, v1193, v1195);
                                                                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 400.
                                                                    returns.extend(Some(v1199));
                                                                    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 v1186,
                                            imm: v1187,
                                        } = &v11.1 {
                                            if let &Opcode::F32const = v1186 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                C::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 v1184,
                                                            imm: v1185,
                                                        } = &v19.1 {
                                                            if let &Opcode::F32const = v1184 {
                                                                let v1200 = C::f32_sub(ctx, v1185, v1187);
                                                                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 404.
                                                                    returns.extend(Some(v1203));
                                                                    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 v1194,
                                            imm: v1195,
                                        } = &v11.1 {
                                            if let &Opcode::F64const = v1194 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                C::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 v1192,
                                                            imm: v1193,
                                                        } = &v19.1 {
                                                            if let &Opcode::F64const = v1192 {
                                                                let v1204 = C::f64_sub(ctx, v1193, v1195);
                                                                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 407.
                                                                    returns.extend(Some(v1207));
                                                                    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 v1186,
                                    imm: v1187,
                                } => {
                                    if let &Opcode::F32const = v1186 {
                                        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 v1184,
                                                            imm: v1185,
                                                        } = &v19.1 {
                                                            if let &Opcode::F32const = v1184 {
                                                                let v1208 = C::f32_mul(ctx, v1185, v1187);
                                                                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 411.
                                                                    returns.extend(Some(v1211));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryIeee64 {
                                    opcode: ref v1194,
                                    imm: v1195,
                                } => {
                                    if let &Opcode::F64const = v1194 {
                                        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 v1192,
                                                            imm: v1193,
                                                        } = &v19.1 {
                                                            if let &Opcode::F64const = v1192 {
                                                                let v1212 = C::f64_mul(ctx, v1193, v1195);
                                                                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 414.
                                                                    returns.extend(Some(v1215));
                                                                    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 v1186,
                                            imm: v1187,
                                        } = &v11.1 {
                                            if let &Opcode::F32const = v1186 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                C::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 v1184,
                                                            imm: v1185,
                                                        } = &v19.1 {
                                                            if let &Opcode::F32const = v1184 {
                                                                let v1216 = C::f32_div(ctx, v1185, v1187);
                                                                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 418.
                                                                    returns.extend(Some(v1219));
                                                                    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 v1194,
                                            imm: v1195,
                                        } = &v11.1 {
                                            if let &Opcode::F64const = v1194 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                C::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 v1192,
                                                            imm: v1193,
                                                        } = &v19.1 {
                                                            if let &Opcode::F64const = v1192 {
                                                                let v1220 = C::f64_div(ctx, v1193, v1195);
                                                                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 421.
                                                                    returns.extend(Some(v1223));
                                                                    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 v1266,
                                            imm: v1267,
                                        } = &v11.1 {
                                            if let &Opcode::F16const = v1266 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                C::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 v1264,
                                                            imm: v1265,
                                                        } = &v19.1 {
                                                            if let &Opcode::F16const = v1264 {
                                                                let v1342 = C::f16_copysign(ctx, v1265, v1267);
                                                                let v1343 = constructor_f16const(ctx, F16, v1342);
                                                                let v1344 = C::subsume(ctx, v1343);
                                                                // Rule at src/opts/cprop.isle line 504.
                                                                returns.extend(Some(v1344));
                                                                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 v1186,
                                            imm: v1187,
                                        } = &v11.1 {
                                            if let &Opcode::F32const = v1186 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                C::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 v1184,
                                                            imm: v1185,
                                                        } = &v19.1 {
                                                            if let &Opcode::F32const = v1184 {
                                                                let v1345 = C::f32_copysign(ctx, v1185, v1187);
                                                                let v1346 = constructor_f32const(ctx, F32, v1345);
                                                                let v1347 = C::subsume(ctx, v1346);
                                                                // Rule at src/opts/cprop.isle line 506.
                                                                returns.extend(Some(v1347));
                                                                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 v1194,
                                            imm: v1195,
                                        } = &v11.1 {
                                            if let &Opcode::F64const = v1194 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                C::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 v1192,
                                                            imm: v1193,
                                                        } = &v19.1 {
                                                            if let &Opcode::F64const = v1192 {
                                                                let v1348 = C::f64_copysign(ctx, v1193, v1195);
                                                                let v1349 = constructor_f64const(ctx, F64, v1348);
                                                                let v1350 = C::subsume(ctx, v1349);
                                                                // Rule at src/opts/cprop.isle line 508.
                                                                returns.extend(Some(v1350));
                                                                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 v1285,
                                            constant_handle: v1286,
                                        } = &v11.1 {
                                            if let &Opcode::F128const = v1285 {
                                                let v1287 = C::ieee128_constant_extractor(ctx, v1286);
                                                if let Some(v1288) = v1287 {
                                                    let mut v18 = C::inst_data_value_etor_returns::default();
                                                    C::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 v1281,
                                                                constant_handle: v1282,
                                                            } = &v19.1 {
                                                                if let &Opcode::F128const = v1281 {
                                                                    let v1283 = C::ieee128_constant_extractor(ctx, v1282);
                                                                    if let Some(v1284) = v1283 {
                                                                        let v1351 = C::f128_copysign(ctx, v1284, v1288);
                                                                        let v1352 = C::ieee128_constant(ctx, v1351);
                                                                        let v1353 = constructor_f128const(ctx, F128, v1352);
                                                                        let v1354 = C::subsume(ctx, v1353);
                                                                        // Rule at src/opts/cprop.isle line 510.
                                                                        returns.extend(Some(v1354));
                                                                        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 v1266,
                                            imm: v1267,
                                        } = &v11.1 {
                                            if let &Opcode::F16const = v1266 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                C::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 v1264,
                                                            imm: v1265,
                                                        } = &v19.1 {
                                                            if let &Opcode::F16const = v1264 {
                                                                let v1268 = C::f16_min(ctx, v1265, v1267);
                                                                if let Some(v1269) = v1268 {
                                                                    let v1271 = constructor_f16const(ctx, F16, v1269);
                                                                    let v1272 = C::subsume(ctx, v1271);
                                                                    // Rule at src/opts/cprop.isle line 460.
                                                                    returns.extend(Some(v1272));
                                                                    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 v1186,
                                            imm: v1187,
                                        } = &v11.1 {
                                            if let &Opcode::F32const = v1186 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                C::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 v1184,
                                                            imm: v1185,
                                                        } = &v19.1 {
                                                            if let &Opcode::F32const = v1184 {
                                                                let v1273 = C::f32_min(ctx, v1185, v1187);
                                                                if let Some(v1274) = v1273 {
                                                                    let v1275 = constructor_f32const(ctx, F32, v1274);
                                                                    let v1276 = C::subsume(ctx, v1275);
                                                                    // Rule at src/opts/cprop.isle line 463.
                                                                    returns.extend(Some(v1276));
                                                                    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 v1194,
                                            imm: v1195,
                                        } = &v11.1 {
                                            if let &Opcode::F64const = v1194 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                C::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 v1192,
                                                            imm: v1193,
                                                        } = &v19.1 {
                                                            if let &Opcode::F64const = v1192 {
                                                                let v1277 = C::f64_min(ctx, v1193, v1195);
                                                                if let Some(v1278) = v1277 {
                                                                    let v1279 = constructor_f64const(ctx, F64, v1278);
                                                                    let v1280 = C::subsume(ctx, v1279);
                                                                    // Rule at src/opts/cprop.isle line 466.
                                                                    returns.extend(Some(v1280));
                                                                    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 v1285,
                                            constant_handle: v1286,
                                        } = &v11.1 {
                                            if let &Opcode::F128const = v1285 {
                                                let v1287 = C::ieee128_constant_extractor(ctx, v1286);
                                                if let Some(v1288) = v1287 {
                                                    let mut v18 = C::inst_data_value_etor_returns::default();
                                                    C::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 v1281,
                                                                constant_handle: v1282,
                                                            } = &v19.1 {
                                                                if let &Opcode::F128const = v1281 {
                                                                    let v1283 = C::ieee128_constant_extractor(ctx, v1282);
                                                                    if let Some(v1284) = v1283 {
                                                                        let v1289 = C::f128_min(ctx, v1284, v1288);
                                                                        if let Some(v1290) = v1289 {
                                                                            let v1292 = C::ieee128_constant(ctx, v1290);
                                                                            let v1293 = constructor_f128const(ctx, F128, v1292);
                                                                            let v1294 = C::subsume(ctx, v1293);
                                                                            // Rule at src/opts/cprop.isle line 469.
                                                                            returns.extend(Some(v1294));
                                                                            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 v1266,
                                            imm: v1267,
                                        } = &v11.1 {
                                            if let &Opcode::F16const = v1266 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                C::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 v1264,
                                                            imm: v1265,
                                                        } = &v19.1 {
                                                            if let &Opcode::F16const = v1264 {
                                                                let v1295 = C::f16_max(ctx, v1265, v1267);
                                                                if let Some(v1296) = v1295 {
                                                                    let v1297 = constructor_f16const(ctx, F16, v1296);
                                                                    let v1298 = C::subsume(ctx, v1297);
                                                                    // Rule at src/opts/cprop.isle line 473.
                                                                    returns.extend(Some(v1298));
                                                                    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 v1186,
                                            imm: v1187,
                                        } = &v11.1 {
                                            if let &Opcode::F32const = v1186 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                C::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 v1184,
                                                            imm: v1185,
                                                        } = &v19.1 {
                                                            if let &Opcode::F32const = v1184 {
                                                                let v1299 = C::f32_max(ctx, v1185, v1187);
                                                                if let Some(v1300) = v1299 {
                                                                    let v1301 = constructor_f32const(ctx, F32, v1300);
                                                                    let v1302 = C::subsume(ctx, v1301);
                                                                    // Rule at src/opts/cprop.isle line 476.
                                                                    returns.extend(Some(v1302));
                                                                    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 v1194,
                                            imm: v1195,
                                        } = &v11.1 {
                                            if let &Opcode::F64const = v1194 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                C::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 v1192,
                                                            imm: v1193,
                                                        } = &v19.1 {
                                                            if let &Opcode::F64const = v1192 {
                                                                let v1303 = C::f64_max(ctx, v1193, v1195);
                                                                if let Some(v1304) = v1303 {
                                                                    let v1305 = constructor_f64const(ctx, F64, v1304);
                                                                    let v1306 = C::subsume(ctx, v1305);
                                                                    // Rule at src/opts/cprop.isle line 479.
                                                                    returns.extend(Some(v1306));
                                                                    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 v1285,
                                            constant_handle: v1286,
                                        } = &v11.1 {
                                            if let &Opcode::F128const = v1285 {
                                                let v1287 = C::ieee128_constant_extractor(ctx, v1286);
                                                if let Some(v1288) = v1287 {
                                                    let mut v18 = C::inst_data_value_etor_returns::default();
                                                    C::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 v1281,
                                                                constant_handle: v1282,
                                                            } = &v19.1 {
                                                                if let &Opcode::F128const = v1281 {
                                                                    let v1283 = C::ieee128_constant_extractor(ctx, v1282);
                                                                    if let Some(v1284) = v1283 {
                                                                        let v1307 = C::f128_max(ctx, v1284, v1288);
                                                                        if let Some(v1308) = v1307 {
                                                                            let v1309 = C::ieee128_constant(ctx, v1308);
                                                                            let v1310 = constructor_f128const(ctx, F128, v1309);
                                                                            let v1311 = C::subsume(ctx, v1310);
                                                                            // Rule at src/opts/cprop.isle line 482.
                                                                            returns.extend(Some(v1311));
                                                                            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 v1148,
                                                        imm: v1149,
                                                    } = &v259.1 {
                                                        if let &Opcode::Iconst = v1148 {
                                                            let v1415 = C::u64_from_imm64(ctx, v1149);
                                                            if v1415 == 0x3f_u64 {
                                                                let v1416 = constructor_sextend(ctx, I128, v7.0);
                                                                // Rule at src/opts/extends.isle line 94.
                                                                returns.extend(Some(v1416));
                                                                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 v1414 = constructor_uextend(ctx, I128, v7.0);
                                                // Rule at src/opts/extends.isle line 93.
                                                returns.extend(Some(v1414));
                                                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 v739 = constructor_eq(ctx, v2.0, v200.1, v166.1);
                                                                    let v1421 = C::subsume(ctx, v739);
                                                                    // Rule at src/opts/icmp.isle line 26.
                                                                    returns.extend(Some(v1421));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v166.0 == v200.1 {
                                                                    let v735 = constructor_eq(ctx, v2.0, v200.0, v166.1);
                                                                    let v1419 = C::subsume(ctx, v735);
                                                                    // Rule at src/opts/icmp.isle line 22.
                                                                    returns.extend(Some(v1419));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v166.1 == v200.0 {
                                                                    let v737 = constructor_eq(ctx, v2.0, v200.1, v166.0);
                                                                    let v1420 = C::subsume(ctx, v737);
                                                                    // Rule at src/opts/icmp.isle line 24.
                                                                    returns.extend(Some(v1420));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v166.1 == v200.1 {
                                                                    let v733 = constructor_eq(ctx, v2.0, v200.0, v166.0);
                                                                    let v1418 = C::subsume(ctx, v733);
                                                                    // Rule at src/opts/icmp.isle line 20.
                                                                    returns.extend(Some(v1418));
                                                                    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 v1087 = constructor_isub(ctx, v161.0, v166.1, v200.1);
                                                                                        let v1088 = constructor_iadd(ctx, v154.0, v166.0, v1087);
                                                                                        let v1089 = constructor_eq(ctx, v2.0, v200.0, v1088);
                                                                                        // Rule at src/opts/cprop.isle line 256.
                                                                                        returns.extend(Some(v1089));
                                                                                        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 v1081 = constructor_isub(ctx, v154.0, v150.1, v200.1);
                                                                            let v1082 = constructor_eq(ctx, v2.0, v200.0, v1081);
                                                                            // Rule at src/opts/cprop.isle line 246.
                                                                            returns.extend(Some(v1082));
                                                                            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 v1986,
                                                            args: ref v1987,
                                                            cond: ref v1988,
                                                        } => {
                                                            if let &Opcode::Icmp = v1986 {
                                                                match v1988 {
                                                                    &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 v1980,
                                                                                    args: ref v1981,
                                                                                    cond: ref v1982,
                                                                                } = &v221.1 {
                                                                                    if let &Opcode::Icmp = v1980 {
                                                                                        if let &IntCC::SignedGreaterThan = v1982 {
                                                                                            if v204.0 == v221.0 {
                                                                                                let v1983 = C::unpack_value_array_2(ctx, v1981);
                                                                                                let v1989 = C::unpack_value_array_2(ctx, v1987);
                                                                                                if v1983.0 == v1989.0 {
                                                                                                    if v1983.1 == v1989.1 {
                                                                                                        let mut v1372 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                        C::inst_data_value_tupled_etor(ctx, v150.1, &mut v1372);
                                                                                                        let mut v1372 = v1372.into_context_iter();
                                                                                                        while let Some(v1373) = v1372.next(ctx) {
                                                                                                            let v1374 = C::iconst_sextend_etor(ctx, v1373);
                                                                                                            if let Some(v1375) = v1374 {
                                                                                                                match v1375.1 {
                                                                                                                    -1_i64 => {
                                                                                                                        let v1994 = constructor_slt(ctx, v221.0, v1983.0, v1983.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 178.
                                                                                                                        returns.extend(Some(v1994));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                    0_i64 => {
                                                                                                                        let v1992 = constructor_eq(ctx, v221.0, v1983.0, v1983.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 145.
                                                                                                                        returns.extend(Some(v1992));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                    1_i64 => {
                                                                                                                        let v1998 = constructor_sgt(ctx, v221.0, v1983.0, v1983.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 186.
                                                                                                                        returns.extend(Some(v1998));
                                                                                                                        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 v1980,
                                                                                    args: ref v1981,
                                                                                    cond: ref v1982,
                                                                                } = &v221.1 {
                                                                                    if let &Opcode::Icmp = v1980 {
                                                                                        if let &IntCC::UnsignedGreaterThan = v1982 {
                                                                                            if v204.0 == v221.0 {
                                                                                                let v1983 = C::unpack_value_array_2(ctx, v1981);
                                                                                                let v1989 = C::unpack_value_array_2(ctx, v1987);
                                                                                                if v1983.0 == v1989.0 {
                                                                                                    if v1983.1 == v1989.1 {
                                                                                                        let mut v1372 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                        C::inst_data_value_tupled_etor(ctx, v150.1, &mut v1372);
                                                                                                        let mut v1372 = v1372.into_context_iter();
                                                                                                        while let Some(v1373) = v1372.next(ctx) {
                                                                                                            let v1374 = C::iconst_sextend_etor(ctx, v1373);
                                                                                                            if let Some(v1375) = v1374 {
                                                                                                                match v1375.1 {
                                                                                                                    -1_i64 => {
                                                                                                                        let v1995 = constructor_ult(ctx, v221.0, v1983.0, v1983.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 180.
                                                                                                                        returns.extend(Some(v1995));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                    0_i64 => {
                                                                                                                        let v1992 = constructor_eq(ctx, v221.0, v1983.0, v1983.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 147.
                                                                                                                        returns.extend(Some(v1992));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                    1_i64 => {
                                                                                                                        let v1999 = constructor_ugt(ctx, v221.0, v1983.0, v1983.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 188.
                                                                                                                        returns.extend(Some(v1999));
                                                                                                                        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 v1084 = constructor_iadd(ctx, v154.0, v150.1, v200.1);
                                                                            let v1085 = constructor_eq(ctx, v2.0, v200.0, v1084);
                                                                            // Rule at src/opts/cprop.isle line 251.
                                                                            returns.extend(Some(v1085));
                                                                            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 v1426 = constructor_iadd(ctx, v154.0, v200.0, v166.1);
                                                            let v1427 = constructor_iadd(ctx, v161.0, v166.0, v200.1);
                                                            let v1428 = constructor_eq(ctx, v2.0, v1426, v1427);
                                                            // Rule at src/opts/icmp.isle line 40.
                                                            returns.extend(Some(v1428));
                                                            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 v941,
                                                                        arg: v942,
                                                                    } = &v204.1 {
                                                                        if let &Opcode::Bnot = v941 {
                                                                            if v302 == v942 {
                                                                                if v154.0 == v204.0 {
                                                                                    let v943 = constructor_bor(ctx, v154.0, v942, v200.0);
                                                                                    let v939 = constructor_iconst_s(ctx, v154.0, -1_i64);
                                                                                    let v944 = constructor_eq(ctx, v2.0, v943, v939);
                                                                                    // Rule at src/opts/bitops.isle line 700.
                                                                                    returns.extend(Some(v944));
                                                                                    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 v936,
                                                                        arg: v937,
                                                                    } = &v221.1 {
                                                                        if let &Opcode::Bnot = v936 {
                                                                            if v302 == v937 {
                                                                                if v154.0 == v221.0 {
                                                                                    let v938 = constructor_bor(ctx, v154.0, v937, v200.1);
                                                                                    let v939 = constructor_iconst_s(ctx, v154.0, -1_i64);
                                                                                    let v940 = constructor_eq(ctx, v2.0, v938, v939);
                                                                                    // Rule at src/opts/bitops.isle line 699.
                                                                                    returns.extend(Some(v940));
                                                                                    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 v739 = constructor_eq(ctx, v2.0, v200.1, v166.1);
                                                                    // Rule at src/opts/bitops.isle line 317.
                                                                    returns.extend(Some(v739));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    let v740 = constructor_eq(ctx, v2.0, v166.1, v200.1);
                                                                    // Rule at src/opts/bitops.isle line 318.
                                                                    returns.extend(Some(v740));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v166.0 == v200.1 {
                                                                    let v735 = constructor_eq(ctx, v2.0, v200.0, v166.1);
                                                                    // Rule at src/opts/bitops.isle line 313.
                                                                    returns.extend(Some(v735));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    let v738 = constructor_eq(ctx, v2.0, v166.1, v200.0);
                                                                    // Rule at src/opts/bitops.isle line 316.
                                                                    returns.extend(Some(v738));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v166.1 == v200.0 {
                                                                    let v736 = constructor_eq(ctx, v2.0, v166.0, v200.1);
                                                                    // Rule at src/opts/bitops.isle line 314.
                                                                    returns.extend(Some(v736));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    let v737 = constructor_eq(ctx, v2.0, v200.1, v166.0);
                                                                    // Rule at src/opts/bitops.isle line 315.
                                                                    returns.extend(Some(v737));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v166.1 == v200.1 {
                                                                    let v733 = constructor_eq(ctx, v2.0, v200.0, v166.0);
                                                                    // Rule at src/opts/bitops.isle line 311.
                                                                    returns.extend(Some(v733));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    let v734 = constructor_eq(ctx, v2.0, v166.0, v200.0);
                                                                    // Rule at src/opts/bitops.isle line 312.
                                                                    returns.extend(Some(v734));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                    &InstructionData::Ternary {
                                        opcode: ref v1545,
                                        args: ref v1546,
                                    } => {
                                        if let &Opcode::Select = v1545 {
                                            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 v1547 = C::unpack_value_array_3(ctx, v1546);
                                                        let mut v1600 = C::inst_data_value_etor_returns::default();
                                                        C::inst_data_value_etor(ctx, v1547.1, &mut v1600);
                                                        let mut v1600 = v1600.into_context_iter();
                                                        while let Some(v1601) = v1600.next(ctx) {
                                                            if let &InstructionData::UnaryImm {
                                                                opcode: ref v1604,
                                                                imm: v1605,
                                                            } = &v1601.1 {
                                                                if let &Opcode::Iconst = v1604 {
                                                                    let mut v1607 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v1547.2, &mut v1607);
                                                                    let mut v1607 = v1607.into_context_iter();
                                                                    while let Some(v1608) = v1607.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v1611,
                                                                            imm: v1612,
                                                                        } = &v1608.1 {
                                                                            if let &Opcode::Iconst = v1611 {
                                                                                let v1606 = C::u64_from_imm64(ctx, v1605);
                                                                                let v1613 = C::u64_from_imm64(ctx, v1612);
                                                                                let v1614 = C::u64_eq(ctx, v1606, v1613);
                                                                                if v1614 == false {
                                                                                    let v212 = C::u64_from_imm64(ctx, v211);
                                                                                    if v212 == v1606 {
                                                                                        let v1599 = C::value_type(ctx, v1547.0);
                                                                                        let v1615 = constructor_iconst_u(ctx, v1599, 0x0_u64);
                                                                                        let v1616 = constructor_ne(ctx, v154.0, v1547.0, v1615);
                                                                                        // Rule at src/opts/icmp.isle line 385.
                                                                                        returns.extend(Some(v1616));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v212 == v1613 {
                                                                                        let v1599 = C::value_type(ctx, v1547.0);
                                                                                        let v1615 = constructor_iconst_u(ctx, v1599, 0x0_u64);
                                                                                        let v1617 = constructor_eq(ctx, v154.0, v1547.0, v1615);
                                                                                        // Rule at src/opts/icmp.isle line 393.
                                                                                        returns.extend(Some(v1617));
                                                                                        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 v949,
                                                                        arg: v950,
                                                                    } = &v170.1 {
                                                                        if let &Opcode::Bnot = v949 {
                                                                            if v300 == v950 {
                                                                                if v154.0 == v170.0 {
                                                                                    let v951 = constructor_bor(ctx, v154.0, v300, v166.0);
                                                                                    let v939 = constructor_iconst_s(ctx, v154.0, -1_i64);
                                                                                    let v952 = constructor_eq(ctx, v2.0, v951, v939);
                                                                                    // Rule at src/opts/bitops.isle line 702.
                                                                                    returns.extend(Some(v952));
                                                                                    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 v945,
                                                                        arg: v946,
                                                                    } = &v185.1 {
                                                                        if let &Opcode::Bnot = v945 {
                                                                            if v300 == v946 {
                                                                                if v154.0 == v185.0 {
                                                                                    let v947 = constructor_bor(ctx, v154.0, v300, v166.1);
                                                                                    let v939 = constructor_iconst_s(ctx, v154.0, -1_i64);
                                                                                    let v948 = constructor_eq(ctx, v2.0, v947, v939);
                                                                                    // Rule at src/opts/bitops.isle line 701.
                                                                                    returns.extend(Some(v948));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                if v150.1 == v300 {
                                                    let v53 = constructor_iconst_u(ctx, v2.0, 0x0_u64);
                                                    let v54 = C::subsume(ctx, v53);
                                                    // Rule at src/opts/icmp.isle line 478.
                                                    returns.extend(Some(v54));
                                                    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 v1623 = constructor_slt(ctx, v2.0, v300, v291);
                                                                // Rule at src/opts/icmp.isle line 446.
                                                                returns.extend(Some(v1623));
                                                                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 v1618 = constructor_iconst_u(ctx, v154.0, 0x1_u64);
                                                                let v1619 = constructor_band(ctx, v154.0, v300, v1618);
                                                                let v1620 = constructor_iconst_u(ctx, v154.0, 0x0_u64);
                                                                let v1621 = constructor_ne(ctx, v2.0, v1619, v1620);
                                                                // Rule at src/opts/icmp.isle line 437.
                                                                returns.extend(Some(v1621));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            &Opcode::Sextend => {
                                                let mut v1372 = C::inst_data_value_tupled_etor_returns::default();
                                                C::inst_data_value_tupled_etor(ctx, v150.1, &mut v1372);
                                                let mut v1372 = v1372.into_context_iter();
                                                while let Some(v1373) = v1372.next(ctx) {
                                                    let v1374 = C::iconst_sextend_etor(ctx, v1373);
                                                    if let Some(v1375) = v1374 {
                                                        if v1375.1 == 0_i64 {
                                                            let v1370 = C::value_type(ctx, v300);
                                                            let v1379 = constructor_iconst_s(ctx, v1370, 0_i64);
                                                            let v1380 = constructor_eq(ctx, v1370, v300, v1379);
                                                            // Rule at src/opts/extends.isle line 39.
                                                            returns.extend(Some(v1380));
                                                            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 v1536 = C::ty_int(ctx, v161.0);
                                                if let Some(v1537) = v1536 {
                                                    let v166 = C::unpack_value_array_2(ctx, v165);
                                                    if v150.0 == v166.0 {
                                                        let v1538 = constructor_iconst_u(ctx, v1537, 0x0_u64);
                                                        let v1539 = constructor_eq(ctx, v2.0, v166.1, v1538);
                                                        let v1540 = C::subsume(ctx, v1539);
                                                        // Rule at src/opts/icmp.isle line 294.
                                                        returns.extend(Some(v1540));
                                                        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 v1430 = C::uextend_maybe_etor_returns::default();
                                                    C::uextend_maybe_etor(ctx, v150.0, &mut v1430);
                                                    let mut v1430 = v1430.into_context_iter();
                                                    while let Some(v1431) = v1430.next(ctx) {
                                                        let mut v1434 = C::inst_data_value_etor_returns::default();
                                                        C::inst_data_value_etor(ctx, v1431.1, &mut v1434);
                                                        let mut v1434 = v1434.into_context_iter();
                                                        while let Some(v1435) = v1434.next(ctx) {
                                                            if let &InstructionData::IntCompare {
                                                                opcode: ref v1438,
                                                                args: ref v1439,
                                                                cond: ref v1440,
                                                            } = &v1435.1 {
                                                                if let &Opcode::Icmp = v1438 {
                                                                    if v2.0 == v1435.0 {
                                                                        let v1451 = &C::intcc_complement(ctx, v1440);
                                                                        let v1441 = C::unpack_value_array_2(ctx, v1439);
                                                                        let v1452 = constructor_icmp(ctx, v2.0, v1451, v1441.0, v1441.1);
                                                                        let v1453 = C::subsume(ctx, v1452);
                                                                        // Rule at src/opts/icmp.isle line 62.
                                                                        returns.extend(Some(v1453));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                0x1_u64 => {
                                                    let mut v1430 = C::uextend_maybe_etor_returns::default();
                                                    C::uextend_maybe_etor(ctx, v150.0, &mut v1430);
                                                    let mut v1430 = v1430.into_context_iter();
                                                    while let Some(v1431) = v1430.next(ctx) {
                                                        let mut v1434 = C::inst_data_value_etor_returns::default();
                                                        C::inst_data_value_etor(ctx, v1431.1, &mut v1434);
                                                        let mut v1434 = v1434.into_context_iter();
                                                        while let Some(v1435) = v1434.next(ctx) {
                                                            if let &InstructionData::IntCompare {
                                                                opcode: ref v1438,
                                                                args: ref v1439,
                                                                cond: ref v1440,
                                                            } = &v1435.1 {
                                                                if let &Opcode::Icmp = v1438 {
                                                                    let v1444 = C::subsume(ctx, v1431.1);
                                                                    // Rule at src/opts/icmp.isle line 76.
                                                                    returns.extend(Some(v1444));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                _ => {}
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                            if v150.0 == v150.1 {
                                let v290 = constructor_cmp_true(ctx, v2.0);
                                let v1417 = C::subsume(ctx, v290);
                                // Rule at src/opts/icmp.isle line 4.
                                returns.extend(Some(v1417));
                                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 v831 = constructor_ne(ctx, v2.0, v200.1, v166.1);
                                                                    let v1425 = C::subsume(ctx, v831);
                                                                    // Rule at src/opts/icmp.isle line 34.
                                                                    returns.extend(Some(v1425));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v166.0 == v200.1 {
                                                                    let v827 = constructor_ne(ctx, v2.0, v200.0, v166.1);
                                                                    let v1423 = C::subsume(ctx, v827);
                                                                    // Rule at src/opts/icmp.isle line 30.
                                                                    returns.extend(Some(v1423));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v166.1 == v200.0 {
                                                                    let v829 = constructor_ne(ctx, v2.0, v200.1, v166.0);
                                                                    let v1424 = C::subsume(ctx, v829);
                                                                    // Rule at src/opts/icmp.isle line 32.
                                                                    returns.extend(Some(v1424));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v166.1 == v200.1 {
                                                                    let v825 = constructor_ne(ctx, v2.0, v200.0, v166.0);
                                                                    let v1422 = C::subsume(ctx, v825);
                                                                    // Rule at src/opts/icmp.isle line 28.
                                                                    returns.extend(Some(v1422));
                                                                    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 v1087 = constructor_isub(ctx, v161.0, v166.1, v200.1);
                                                                                        let v1088 = constructor_iadd(ctx, v154.0, v166.0, v1087);
                                                                                        let v1090 = constructor_ne(ctx, v2.0, v200.0, v1088);
                                                                                        // Rule at src/opts/cprop.isle line 258.
                                                                                        returns.extend(Some(v1090));
                                                                                        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 v1081 = constructor_isub(ctx, v154.0, v150.1, v200.1);
                                                                            let v1083 = constructor_ne(ctx, v2.0, v200.0, v1081);
                                                                            // Rule at src/opts/cprop.isle line 248.
                                                                            returns.extend(Some(v1083));
                                                                            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 v1986,
                                                            args: ref v1987,
                                                            cond: ref v1988,
                                                        } => {
                                                            if let &Opcode::Icmp = v1986 {
                                                                match v1988 {
                                                                    &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 v1980,
                                                                                    args: ref v1981,
                                                                                    cond: ref v1982,
                                                                                } = &v221.1 {
                                                                                    if let &Opcode::Icmp = v1980 {
                                                                                        if let &IntCC::SignedGreaterThan = v1982 {
                                                                                            if v204.0 == v221.0 {
                                                                                                let v1983 = C::unpack_value_array_2(ctx, v1981);
                                                                                                let v1989 = C::unpack_value_array_2(ctx, v1987);
                                                                                                if v1983.0 == v1989.0 {
                                                                                                    if v1983.1 == v1989.1 {
                                                                                                        let mut v1372 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                        C::inst_data_value_tupled_etor(ctx, v150.1, &mut v1372);
                                                                                                        let mut v1372 = v1372.into_context_iter();
                                                                                                        while let Some(v1373) = v1372.next(ctx) {
                                                                                                            let v1374 = C::iconst_sextend_etor(ctx, v1373);
                                                                                                            if let Some(v1375) = v1374 {
                                                                                                                match v1375.1 {
                                                                                                                    -1_i64 => {
                                                                                                                        let v2000 = constructor_sge(ctx, v221.0, v1983.0, v1983.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 182.
                                                                                                                        returns.extend(Some(v2000));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                    0_i64 => {
                                                                                                                        let v1993 = constructor_ne(ctx, v221.0, v1983.0, v1983.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 150.
                                                                                                                        returns.extend(Some(v1993));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                    1_i64 => {
                                                                                                                        let v1996 = constructor_sle(ctx, v221.0, v1983.0, v1983.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 190.
                                                                                                                        returns.extend(Some(v1996));
                                                                                                                        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 v1980,
                                                                                    args: ref v1981,
                                                                                    cond: ref v1982,
                                                                                } = &v221.1 {
                                                                                    if let &Opcode::Icmp = v1980 {
                                                                                        if let &IntCC::UnsignedGreaterThan = v1982 {
                                                                                            if v204.0 == v221.0 {
                                                                                                let v1983 = C::unpack_value_array_2(ctx, v1981);
                                                                                                let v1989 = C::unpack_value_array_2(ctx, v1987);
                                                                                                if v1983.0 == v1989.0 {
                                                                                                    if v1983.1 == v1989.1 {
                                                                                                        let mut v1372 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                        C::inst_data_value_tupled_etor(ctx, v150.1, &mut v1372);
                                                                                                        let mut v1372 = v1372.into_context_iter();
                                                                                                        while let Some(v1373) = v1372.next(ctx) {
                                                                                                            let v1374 = C::iconst_sextend_etor(ctx, v1373);
                                                                                                            if let Some(v1375) = v1374 {
                                                                                                                match v1375.1 {
                                                                                                                    -1_i64 => {
                                                                                                                        let v2001 = constructor_uge(ctx, v221.0, v1983.0, v1983.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 184.
                                                                                                                        returns.extend(Some(v2001));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                    0_i64 => {
                                                                                                                        let v1993 = constructor_ne(ctx, v221.0, v1983.0, v1983.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 152.
                                                                                                                        returns.extend(Some(v1993));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                    1_i64 => {
                                                                                                                        let v1997 = constructor_ule(ctx, v221.0, v1983.0, v1983.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 192.
                                                                                                                        returns.extend(Some(v1997));
                                                                                                                        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 v1084 = constructor_iadd(ctx, v154.0, v150.1, v200.1);
                                                                            let v1086 = constructor_ne(ctx, v2.0, v200.0, v1084);
                                                                            // Rule at src/opts/cprop.isle line 253.
                                                                            returns.extend(Some(v1086));
                                                                            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 v1426 = constructor_iadd(ctx, v154.0, v200.0, v166.1);
                                                            let v1427 = constructor_iadd(ctx, v161.0, v166.0, v200.1);
                                                            let v1429 = constructor_ne(ctx, v2.0, v1426, v1427);
                                                            // Rule at src/opts/icmp.isle line 42.
                                                            returns.extend(Some(v1429));
                                                            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 v831 = constructor_ne(ctx, v2.0, v200.1, v166.1);
                                                                    // Rule at src/opts/bitops.isle line 468.
                                                                    returns.extend(Some(v831));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    let v832 = constructor_ne(ctx, v2.0, v166.1, v200.1);
                                                                    // Rule at src/opts/bitops.isle line 469.
                                                                    returns.extend(Some(v832));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v166.0 == v200.1 {
                                                                    let v827 = constructor_ne(ctx, v2.0, v200.0, v166.1);
                                                                    // Rule at src/opts/bitops.isle line 464.
                                                                    returns.extend(Some(v827));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    let v830 = constructor_ne(ctx, v2.0, v166.1, v200.0);
                                                                    // Rule at src/opts/bitops.isle line 467.
                                                                    returns.extend(Some(v830));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v166.1 == v200.0 {
                                                                    let v828 = constructor_ne(ctx, v2.0, v166.0, v200.1);
                                                                    // Rule at src/opts/bitops.isle line 465.
                                                                    returns.extend(Some(v828));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    let v829 = constructor_ne(ctx, v2.0, v200.1, v166.0);
                                                                    // Rule at src/opts/bitops.isle line 466.
                                                                    returns.extend(Some(v829));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v166.1 == v200.1 {
                                                                    let v825 = constructor_ne(ctx, v2.0, v200.0, v166.0);
                                                                    // Rule at src/opts/bitops.isle line 462.
                                                                    returns.extend(Some(v825));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    let v826 = constructor_ne(ctx, v2.0, v166.0, v200.0);
                                                                    // Rule at src/opts/bitops.isle line 463.
                                                                    returns.extend(Some(v826));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                    &InstructionData::Ternary {
                                        opcode: ref v1545,
                                        args: ref v1546,
                                    } => {
                                        if let &Opcode::Select = v1545 {
                                            let v1547 = C::unpack_value_array_3(ctx, v1546);
                                            if v150.1 == v1547.1 {
                                                let mut v1551 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v1547.0, &mut v1551);
                                                let mut v1551 = v1551.into_context_iter();
                                                while let Some(v1552) = v1551.next(ctx) {
                                                    if let &InstructionData::IntCompare {
                                                        opcode: ref v1555,
                                                        args: ref v1556,
                                                        cond: ref v1557,
                                                    } = &v1552.1 {
                                                        if let &Opcode::Icmp = v1555 {
                                                            match v1557 {
                                                                &IntCC::SignedLessThan => {
                                                                    if v2.0 == v1552.0 {
                                                                        let v1558 = C::unpack_value_array_2(ctx, v1556);
                                                                        if v150.1 == v1558.0 {
                                                                            if v1547.2 == v1558.1 {
                                                                                let v1561 = constructor_sgt(ctx, v2.0, v1558.0, v1558.1);
                                                                                // Rule at src/opts/icmp.isle line 302.
                                                                                returns.extend(Some(v1561));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &IntCC::UnsignedLessThan => {
                                                                    if v2.0 == v1552.0 {
                                                                        let v1558 = C::unpack_value_array_2(ctx, v1556);
                                                                        if v150.1 == v1558.0 {
                                                                            if v1547.2 == v1558.1 {
                                                                                let v1562 = constructor_ugt(ctx, v2.0, v1558.0, v1558.1);
                                                                                // Rule at src/opts/icmp.isle line 303.
                                                                                returns.extend(Some(v1562));
                                                                                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 v1600 = C::inst_data_value_etor_returns::default();
                                                        C::inst_data_value_etor(ctx, v1547.1, &mut v1600);
                                                        let mut v1600 = v1600.into_context_iter();
                                                        while let Some(v1601) = v1600.next(ctx) {
                                                            if let &InstructionData::UnaryImm {
                                                                opcode: ref v1604,
                                                                imm: v1605,
                                                            } = &v1601.1 {
                                                                if let &Opcode::Iconst = v1604 {
                                                                    let mut v1607 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v1547.2, &mut v1607);
                                                                    let mut v1607 = v1607.into_context_iter();
                                                                    while let Some(v1608) = v1607.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v1611,
                                                                            imm: v1612,
                                                                        } = &v1608.1 {
                                                                            if let &Opcode::Iconst = v1611 {
                                                                                let v1606 = C::u64_from_imm64(ctx, v1605);
                                                                                let v1613 = C::u64_from_imm64(ctx, v1612);
                                                                                let v1614 = C::u64_eq(ctx, v1606, v1613);
                                                                                if v1614 == false {
                                                                                    let v212 = C::u64_from_imm64(ctx, v211);
                                                                                    if v212 == v1606 {
                                                                                        let v1599 = C::value_type(ctx, v1547.0);
                                                                                        let v1615 = constructor_iconst_u(ctx, v1599, 0x0_u64);
                                                                                        let v1617 = constructor_eq(ctx, v154.0, v1547.0, v1615);
                                                                                        // Rule at src/opts/icmp.isle line 401.
                                                                                        returns.extend(Some(v1617));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v212 == v1613 {
                                                                                        let v1599 = C::value_type(ctx, v1547.0);
                                                                                        let v1615 = constructor_iconst_u(ctx, v1599, 0x0_u64);
                                                                                        let v1616 = constructor_ne(ctx, v154.0, v1547.0, v1615);
                                                                                        // Rule at src/opts/icmp.isle line 409.
                                                                                        returns.extend(Some(v1616));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    &InstructionData::Unary {
                                        opcode: ref v299,
                                        arg: v300,
                                    } => {
                                        match v299 {
                                            &Opcode::Bnot => {
                                                if v150.1 == v300 {
                                                    let v290 = constructor_cmp_true(ctx, v2.0);
                                                    let v1417 = C::subsume(ctx, v290);
                                                    // Rule at src/opts/icmp.isle line 481.
                                                    returns.extend(Some(v1417));
                                                    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 v1624 = constructor_sge(ctx, v2.0, v300, v291);
                                                                // Rule at src/opts/icmp.isle line 450.
                                                                returns.extend(Some(v1624));
                                                                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 v1618 = constructor_iconst_u(ctx, v154.0, 0x1_u64);
                                                                let v1619 = constructor_band(ctx, v154.0, v300, v1618);
                                                                let v1620 = constructor_iconst_u(ctx, v154.0, 0x0_u64);
                                                                let v1622 = constructor_eq(ctx, v2.0, v1619, v1620);
                                                                // Rule at src/opts/icmp.isle line 441.
                                                                returns.extend(Some(v1622));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            &Opcode::Sextend => {
                                                let mut v1372 = C::inst_data_value_tupled_etor_returns::default();
                                                C::inst_data_value_tupled_etor(ctx, v150.1, &mut v1372);
                                                let mut v1372 = v1372.into_context_iter();
                                                while let Some(v1373) = v1372.next(ctx) {
                                                    let v1374 = C::iconst_sextend_etor(ctx, v1373);
                                                    if let Some(v1375) = v1374 {
                                                        if v1375.1 == 0_i64 {
                                                            let v1370 = C::value_type(ctx, v300);
                                                            let v1379 = constructor_iconst_s(ctx, v1370, 0_i64);
                                                            let v1381 = constructor_ne(ctx, v1370, v300, v1379);
                                                            // Rule at src/opts/extends.isle line 41.
                                                            returns.extend(Some(v1381));
                                                            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 v1536 = C::ty_int(ctx, v161.0);
                                                if let Some(v1537) = v1536 {
                                                    let v166 = C::unpack_value_array_2(ctx, v165);
                                                    if v150.0 == v166.0 {
                                                        let v1538 = constructor_iconst_u(ctx, v1537, 0x0_u64);
                                                        let v1541 = constructor_ne(ctx, v2.0, v166.1, v1538);
                                                        let v1542 = C::subsume(ctx, v1541);
                                                        // Rule at src/opts/icmp.isle line 295.
                                                        returns.extend(Some(v1542));
                                                        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 v1430 = C::uextend_maybe_etor_returns::default();
                                                    C::uextend_maybe_etor(ctx, v150.0, &mut v1430);
                                                    let mut v1430 = v1430.into_context_iter();
                                                    while let Some(v1431) = v1430.next(ctx) {
                                                        let mut v1434 = C::inst_data_value_etor_returns::default();
                                                        C::inst_data_value_etor(ctx, v1431.1, &mut v1434);
                                                        let mut v1434 = v1434.into_context_iter();
                                                        while let Some(v1435) = v1434.next(ctx) {
                                                            match &v1435.1 {
                                                                &InstructionData::FloatCompare {
                                                                    opcode: ref v1445,
                                                                    args: ref v1446,
                                                                    cond: ref v1447,
                                                                } => {
                                                                    if let &Opcode::Fcmp = v1445 {
                                                                        if v2.0 == v1435.0 {
                                                                            let v1444 = C::subsume(ctx, v1431.1);
                                                                            // Rule at src/opts/icmp.isle line 55.
                                                                            returns.extend(Some(v1444));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                &InstructionData::IntCompare {
                                                                    opcode: ref v1438,
                                                                    args: ref v1439,
                                                                    cond: ref v1440,
                                                                } => {
                                                                    if let &Opcode::Icmp = v1438 {
                                                                        if v2.0 == v1435.0 {
                                                                            let v1444 = C::subsume(ctx, v1431.1);
                                                                            // Rule at src/opts/icmp.isle line 48.
                                                                            returns.extend(Some(v1444));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                    }
                                                    let mut v385 = ContextIterWrapper::<ConstructorVec<_>, _>::default();
                                                    constructor_truthy(ctx, v150.0, &mut v385);
                                                    let mut v385 = v385.into_context_iter();
                                                    while let Some(v386) = v385.next(ctx) {
                                                        let v387 = C::value_type(ctx, v386);
                                                        let v388 = C::ty_int_ref_scalar_64_extract(ctx, v387);
                                                        if let Some(v389) = v388 {
                                                            let v390 = constructor_iconst_u(ctx, v389, 0x0_u64);
                                                            let v391 = constructor_ne(ctx, v2.0, v386, v390);
                                                            // Rule at src/opts/bitops.isle line 122.
                                                            returns.extend(Some(v391));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                                0x1_u64 => {
                                                    let mut v1430 = C::uextend_maybe_etor_returns::default();
                                                    C::uextend_maybe_etor(ctx, v150.0, &mut v1430);
                                                    let mut v1430 = v1430.into_context_iter();
                                                    while let Some(v1431) = v1430.next(ctx) {
                                                        let mut v1434 = C::inst_data_value_etor_returns::default();
                                                        C::inst_data_value_etor(ctx, v1431.1, &mut v1434);
                                                        let mut v1434 = v1434.into_context_iter();
                                                        while let Some(v1435) = v1434.next(ctx) {
                                                            if let &InstructionData::IntCompare {
                                                                opcode: ref v1438,
                                                                args: ref v1439,
                                                                cond: ref v1440,
                                                            } = &v1435.1 {
                                                                if let &Opcode::Icmp = v1438 {
                                                                    if v2.0 == v1435.0 {
                                                                        let v1451 = &C::intcc_complement(ctx, v1440);
                                                                        let v1441 = C::unpack_value_array_2(ctx, v1439);
                                                                        let v1452 = constructor_icmp(ctx, v2.0, v1451, v1441.0, v1441.1);
                                                                        let v1453 = C::subsume(ctx, v1452);
                                                                        // Rule at src/opts/icmp.isle line 69.
                                                                        returns.extend(Some(v1453));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                _ => {}
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                            if v150.0 == v150.1 {
                                let v53 = constructor_iconst_u(ctx, v2.0, 0x0_u64);
                                let v54 = C::subsume(ctx, v53);
                                // Rule at src/opts/icmp.isle line 5.
                                returns.extend(Some(v54));
                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                            }
                        }
                        &IntCC::SignedGreaterThan => {
                            let v334 = C::fits_in_64(ctx, v2.0);
                            if let Some(v335) = v334 {
                                let v1471 = C::ty_int(ctx, v335);
                                if let Some(v1472) = v1471 {
                                    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 v1481 = C::ty_smin(ctx, v161.0);
                                                let v1482 = C::u64_eq(ctx, v212, v1481);
                                                if v1482 == true {
                                                    let v1474 = constructor_ne(ctx, v1472, v150.0, v150.1);
                                                    // Rule at src/opts/icmp.isle line 149.
                                                    returns.extend(Some(v1474));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let v1483 = C::ty_smax(ctx, v161.0);
                                                let v1484 = C::u64_eq(ctx, v212, v1483);
                                                if v1484 == true {
                                                    let v1479 = constructor_iconst_u(ctx, v1472, 0x0_u64);
                                                    let v1480 = C::subsume(ctx, v1479);
                                                    // Rule at src/opts/icmp.isle line 169.
                                                    returns.extend(Some(v1480));
                                                    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 v1726 = constructor_iconst_u(ctx, v335, 0x0_u64);
                                                // Rule at src/opts/selects.isle line 105.
                                                returns.extend(Some(v1726));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            if v150.1 == v200.1 {
                                                let v1726 = constructor_iconst_u(ctx, v335, 0x0_u64);
                                                // Rule at src/opts/selects.isle line 106.
                                                returns.extend(Some(v1726));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                }
                            }
                            let v150 = C::unpack_value_array_2(ctx, v148);
                            let mut v1372 = C::inst_data_value_tupled_etor_returns::default();
                            C::inst_data_value_tupled_etor(ctx, v150.1, &mut v1372);
                            let mut v1372 = v1372.into_context_iter();
                            while let Some(v1373) = v1372.next(ctx) {
                                let v1374 = C::iconst_sextend_etor(ctx, v1373);
                                if let Some(v1375) = v1374 {
                                    match v1375.1 {
                                        -1_i64 => {
                                            let v1495 = constructor_iconst_s(ctx, v1375.0, 0_i64);
                                            let v1498 = constructor_sge(ctx, v2.0, v150.0, v1495);
                                            // Rule at src/opts/icmp.isle line 201.
                                            returns.extend(Some(v1498));
                                            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 v1986,
                                                                    args: ref v1987,
                                                                    cond: ref v1988,
                                                                } = &v204.1 {
                                                                    if let &Opcode::Icmp = v1986 {
                                                                        match v1988 {
                                                                            &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 v1980,
                                                                                        args: ref v1981,
                                                                                        cond: ref v1982,
                                                                                    } = &v221.1 {
                                                                                        if let &Opcode::Icmp = v1980 {
                                                                                            if let &IntCC::SignedGreaterThan = v1982 {
                                                                                                if v204.0 == v221.0 {
                                                                                                    let v1983 = C::unpack_value_array_2(ctx, v1981);
                                                                                                    let v1989 = C::unpack_value_array_2(ctx, v1987);
                                                                                                    if v1983.0 == v1989.0 {
                                                                                                        if v1983.1 == v1989.1 {
                                                                                                            let v1998 = constructor_sgt(ctx, v221.0, v1983.0, v1983.1);
                                                                                                            // Rule at src/opts/spaceship.isle line 166.
                                                                                                            returns.extend(Some(v1998));
                                                                                                            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 v1980,
                                                                                        args: ref v1981,
                                                                                        cond: ref v1982,
                                                                                    } = &v221.1 {
                                                                                        if let &Opcode::Icmp = v1980 {
                                                                                            if let &IntCC::UnsignedGreaterThan = v1982 {
                                                                                                if v204.0 == v221.0 {
                                                                                                    let v1983 = C::unpack_value_array_2(ctx, v1981);
                                                                                                    let v1989 = C::unpack_value_array_2(ctx, v1987);
                                                                                                    if v1983.0 == v1989.0 {
                                                                                                        if v1983.1 == v1989.1 {
                                                                                                            let v1999 = constructor_ugt(ctx, v221.0, v1983.0, v1983.1);
                                                                                                            // Rule at src/opts/spaceship.isle line 168.
                                                                                                            returns.extend(Some(v1999));
                                                                                                            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; }
                                            }
                                        }
                                    }
                                }
                            }
                            if v150.0 == v150.1 {
                                let v53 = constructor_iconst_u(ctx, v2.0, 0x0_u64);
                                let v54 = C::subsume(ctx, v53);
                                // Rule at src/opts/icmp.isle line 8.
                                returns.extend(Some(v54));
                                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 v1986,
                                                            args: ref v1987,
                                                            cond: ref v1988,
                                                        } = &v204.1 {
                                                            if let &Opcode::Icmp = v1986 {
                                                                match v1988 {
                                                                    &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 v1980,
                                                                                args: ref v1981,
                                                                                cond: ref v1982,
                                                                            } = &v221.1 {
                                                                                if let &Opcode::Icmp = v1980 {
                                                                                    if let &IntCC::SignedGreaterThan = v1982 {
                                                                                        if v204.0 == v221.0 {
                                                                                            let v1983 = C::unpack_value_array_2(ctx, v1981);
                                                                                            let v1989 = C::unpack_value_array_2(ctx, v1987);
                                                                                            if v1983.0 == v1989.0 {
                                                                                                if v1983.1 == v1989.1 {
                                                                                                    let mut v1372 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                    C::inst_data_value_tupled_etor(ctx, v150.1, &mut v1372);
                                                                                                    let mut v1372 = v1372.into_context_iter();
                                                                                                    while let Some(v1373) = v1372.next(ctx) {
                                                                                                        let v1374 = C::iconst_sextend_etor(ctx, v1373);
                                                                                                        if let Some(v1375) = v1374 {
                                                                                                            if v1375.1 == 0_i64 {
                                                                                                                let v2000 = constructor_sge(ctx, v221.0, v1983.0, v1983.1);
                                                                                                                // Rule at src/opts/spaceship.isle line 171.
                                                                                                                returns.extend(Some(v2000));
                                                                                                                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 v1980,
                                                                                args: ref v1981,
                                                                                cond: ref v1982,
                                                                            } = &v221.1 {
                                                                                if let &Opcode::Icmp = v1980 {
                                                                                    if let &IntCC::UnsignedGreaterThan = v1982 {
                                                                                        if v204.0 == v221.0 {
                                                                                            let v1983 = C::unpack_value_array_2(ctx, v1981);
                                                                                            let v1989 = C::unpack_value_array_2(ctx, v1987);
                                                                                            if v1983.0 == v1989.0 {
                                                                                                if v1983.1 == v1989.1 {
                                                                                                    let mut v1372 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                    C::inst_data_value_tupled_etor(ctx, v150.1, &mut v1372);
                                                                                                    let mut v1372 = v1372.into_context_iter();
                                                                                                    while let Some(v1373) = v1372.next(ctx) {
                                                                                                        let v1374 = C::iconst_sextend_etor(ctx, v1373);
                                                                                                        if let Some(v1375) = v1374 {
                                                                                                            if v1375.1 == 0_i64 {
                                                                                                                let v2001 = constructor_uge(ctx, v221.0, v1983.0, v1983.1);
                                                                                                                // Rule at src/opts/spaceship.isle line 173.
                                                                                                                returns.extend(Some(v2001));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                    &InstructionData::Unary {
                                        opcode: ref v299,
                                        arg: v300,
                                    } => {
                                        if let &Opcode::Uextend = v299 {
                                            if v154.0 == I64 {
                                                let v1370 = C::value_type(ctx, v300);
                                                if v1370 == 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 v340 = constructor_iconst_u(ctx, v2.0, 0x1_u64);
                                                                    let v1371 = C::subsume(ctx, v340);
                                                                    // Rule at src/opts/extends.isle line 32.
                                                                    returns.extend(Some(v1371));
                                                                    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 v1471 = C::ty_int(ctx, v335);
                                                if let Some(v1472) = v1471 {
                                                    let v212 = C::u64_from_imm64(ctx, v211);
                                                    let v1481 = C::ty_smin(ctx, v161.0);
                                                    let v1482 = C::u64_eq(ctx, v212, v1481);
                                                    if v1482 == true {
                                                        let v1477 = constructor_iconst_u(ctx, v1472, 0x1_u64);
                                                        let v1478 = C::subsume(ctx, v1477);
                                                        // Rule at src/opts/icmp.isle line 154.
                                                        returns.extend(Some(v1478));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                    let v1483 = C::ty_smax(ctx, v161.0);
                                                    let v1484 = C::u64_eq(ctx, v212, v1483);
                                                    if v1484 == true {
                                                        let v1473 = constructor_eq(ctx, v1472, v150.0, v150.1);
                                                        // Rule at src/opts/icmp.isle line 174.
                                                        returns.extend(Some(v1473));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                            if v150.0 == v150.1 {
                                let v290 = constructor_cmp_true(ctx, v2.0);
                                let v1417 = C::subsume(ctx, v290);
                                // Rule at src/opts/icmp.isle line 9.
                                returns.extend(Some(v1417));
                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                            }
                            let mut v1372 = C::inst_data_value_tupled_etor_returns::default();
                            C::inst_data_value_tupled_etor(ctx, v150.1, &mut v1372);
                            let mut v1372 = v1372.into_context_iter();
                            while let Some(v1373) = v1372.next(ctx) {
                                let v1374 = C::iconst_sextend_etor(ctx, v1373);
                                if let Some(v1375) = v1374 {
                                    if v1375.1 == 1_i64 {
                                        let v1495 = constructor_iconst_s(ctx, v1375.0, 0_i64);
                                        let v1496 = constructor_sgt(ctx, v2.0, v150.0, v1495);
                                        // Rule at src/opts/icmp.isle line 195.
                                        returns.extend(Some(v1496));
                                        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 v1986,
                                                            args: ref v1987,
                                                            cond: ref v1988,
                                                        } = &v204.1 {
                                                            if let &Opcode::Icmp = v1986 {
                                                                match v1988 {
                                                                    &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 v1980,
                                                                                args: ref v1981,
                                                                                cond: ref v1982,
                                                                            } = &v221.1 {
                                                                                if let &Opcode::Icmp = v1980 {
                                                                                    if let &IntCC::SignedGreaterThan = v1982 {
                                                                                        if v204.0 == v221.0 {
                                                                                            let v1983 = C::unpack_value_array_2(ctx, v1981);
                                                                                            let v1989 = C::unpack_value_array_2(ctx, v1987);
                                                                                            if v1983.0 == v1989.0 {
                                                                                                if v1983.1 == v1989.1 {
                                                                                                    let mut v1372 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                    C::inst_data_value_tupled_etor(ctx, v150.1, &mut v1372);
                                                                                                    let mut v1372 = v1372.into_context_iter();
                                                                                                    while let Some(v1373) = v1372.next(ctx) {
                                                                                                        let v1374 = C::iconst_sextend_etor(ctx, v1373);
                                                                                                        if let Some(v1375) = v1374 {
                                                                                                            if v1375.1 == 0_i64 {
                                                                                                                let v1994 = constructor_slt(ctx, v221.0, v1983.0, v1983.1);
                                                                                                                // Rule at src/opts/spaceship.isle line 156.
                                                                                                                returns.extend(Some(v1994));
                                                                                                                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 v1980,
                                                                                args: ref v1981,
                                                                                cond: ref v1982,
                                                                            } = &v221.1 {
                                                                                if let &Opcode::Icmp = v1980 {
                                                                                    if let &IntCC::UnsignedGreaterThan = v1982 {
                                                                                        if v204.0 == v221.0 {
                                                                                            let v1983 = C::unpack_value_array_2(ctx, v1981);
                                                                                            let v1989 = C::unpack_value_array_2(ctx, v1987);
                                                                                            if v1983.0 == v1989.0 {
                                                                                                if v1983.1 == v1989.1 {
                                                                                                    let mut v1372 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                    C::inst_data_value_tupled_etor(ctx, v150.1, &mut v1372);
                                                                                                    let mut v1372 = v1372.into_context_iter();
                                                                                                    while let Some(v1373) = v1372.next(ctx) {
                                                                                                        let v1374 = C::iconst_sextend_etor(ctx, v1373);
                                                                                                        if let Some(v1375) = v1374 {
                                                                                                            if v1375.1 == 0_i64 {
                                                                                                                let v1995 = constructor_ult(ctx, v221.0, v1983.0, v1983.1);
                                                                                                                // Rule at src/opts/spaceship.isle line 158.
                                                                                                                returns.extend(Some(v1995));
                                                                                                                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 v1564 = constructor_sgt(ctx, v2.0, v300, v302);
                                                                // Rule at src/opts/icmp.isle line 306.
                                                                returns.extend(Some(v1564));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            &Opcode::Uextend => {
                                                if v154.0 == I64 {
                                                    let v1370 = C::value_type(ctx, v300);
                                                    if v1370 == 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 v1726 = constructor_iconst_u(ctx, v335, 0x0_u64);
                                                    // Rule at src/opts/selects.isle line 107.
                                                    returns.extend(Some(v1726));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v150.0 == v166.1 {
                                                    let v1726 = constructor_iconst_u(ctx, v335, 0x0_u64);
                                                    // Rule at src/opts/selects.isle line 108.
                                                    returns.extend(Some(v1726));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        &InstructionData::UnaryImm {
                                            opcode: ref v210,
                                            imm: v211,
                                        } => {
                                            if let &Opcode::Iconst = v210 {
                                                let v1471 = C::ty_int(ctx, v335);
                                                if let Some(v1472) = v1471 {
                                                    let v212 = C::u64_from_imm64(ctx, v211);
                                                    let v1481 = C::ty_smin(ctx, v161.0);
                                                    let v1482 = C::u64_eq(ctx, v212, v1481);
                                                    if v1482 == true {
                                                        let v1479 = constructor_iconst_u(ctx, v1472, 0x0_u64);
                                                        let v1480 = C::subsume(ctx, v1479);
                                                        // Rule at src/opts/icmp.isle line 139.
                                                        returns.extend(Some(v1480));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                    let v1483 = C::ty_smax(ctx, v161.0);
                                                    let v1484 = C::u64_eq(ctx, v212, v1483);
                                                    if v1484 == true {
                                                        let v1474 = constructor_ne(ctx, v1472, v150.0, v150.1);
                                                        // Rule at src/opts/icmp.isle line 159.
                                                        returns.extend(Some(v1474));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                            }
                            if v150.0 == v150.1 {
                                let v53 = constructor_iconst_u(ctx, v2.0, 0x0_u64);
                                let v54 = C::subsume(ctx, v53);
                                // Rule at src/opts/icmp.isle line 12.
                                returns.extend(Some(v54));
                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                            }
                            let mut v1372 = C::inst_data_value_tupled_etor_returns::default();
                            C::inst_data_value_tupled_etor(ctx, v150.1, &mut v1372);
                            let mut v1372 = v1372.into_context_iter();
                            while let Some(v1373) = v1372.next(ctx) {
                                let v1374 = C::iconst_sextend_etor(ctx, v1373);
                                if let Some(v1375) = v1374 {
                                    if v1375.1 == 1_i64 {
                                        let v1495 = constructor_iconst_s(ctx, v1375.0, 0_i64);
                                        let v1497 = constructor_sle(ctx, v2.0, v150.0, v1495);
                                        // Rule at src/opts/icmp.isle line 198.
                                        returns.extend(Some(v1497));
                                        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 v1986,
                                                        args: ref v1987,
                                                        cond: ref v1988,
                                                    } = &v204.1 {
                                                        if let &Opcode::Icmp = v1986 {
                                                            match v1988 {
                                                                &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 v1980,
                                                                            args: ref v1981,
                                                                            cond: ref v1982,
                                                                        } = &v221.1 {
                                                                            if let &Opcode::Icmp = v1980 {
                                                                                if let &IntCC::SignedGreaterThan = v1982 {
                                                                                    if v204.0 == v221.0 {
                                                                                        let v1983 = C::unpack_value_array_2(ctx, v1981);
                                                                                        let v1989 = C::unpack_value_array_2(ctx, v1987);
                                                                                        if v1983.0 == v1989.0 {
                                                                                            if v1983.1 == v1989.1 {
                                                                                                let mut v1372 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                C::inst_data_value_tupled_etor(ctx, v150.1, &mut v1372);
                                                                                                let mut v1372 = v1372.into_context_iter();
                                                                                                while let Some(v1373) = v1372.next(ctx) {
                                                                                                    let v1374 = C::iconst_sextend_etor(ctx, v1373);
                                                                                                    if let Some(v1375) = v1374 {
                                                                                                        if v1375.1 == 0_i64 {
                                                                                                            let v1996 = constructor_sle(ctx, v221.0, v1983.0, v1983.1);
                                                                                                            // Rule at src/opts/spaceship.isle line 161.
                                                                                                            returns.extend(Some(v1996));
                                                                                                            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 v1980,
                                                                            args: ref v1981,
                                                                            cond: ref v1982,
                                                                        } = &v221.1 {
                                                                            if let &Opcode::Icmp = v1980 {
                                                                                if let &IntCC::UnsignedGreaterThan = v1982 {
                                                                                    if v204.0 == v221.0 {
                                                                                        let v1983 = C::unpack_value_array_2(ctx, v1981);
                                                                                        let v1989 = C::unpack_value_array_2(ctx, v1987);
                                                                                        if v1983.0 == v1989.0 {
                                                                                            if v1983.1 == v1989.1 {
                                                                                                let mut v1372 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                C::inst_data_value_tupled_etor(ctx, v150.1, &mut v1372);
                                                                                                let mut v1372 = v1372.into_context_iter();
                                                                                                while let Some(v1373) = v1372.next(ctx) {
                                                                                                    let v1374 = C::iconst_sextend_etor(ctx, v1373);
                                                                                                    if let Some(v1375) = v1374 {
                                                                                                        if v1375.1 == 0_i64 {
                                                                                                            let v1997 = constructor_ule(ctx, v221.0, v1983.0, v1983.1);
                                                                                                            // Rule at src/opts/spaceship.isle line 163.
                                                                                                            returns.extend(Some(v1997));
                                                                                                            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 v1471 = C::ty_int(ctx, v335);
                                                if let Some(v1472) = v1471 {
                                                    let v212 = C::u64_from_imm64(ctx, v211);
                                                    let v1481 = C::ty_smin(ctx, v161.0);
                                                    let v1482 = C::u64_eq(ctx, v212, v1481);
                                                    if v1482 == true {
                                                        let v1473 = constructor_eq(ctx, v1472, v150.0, v150.1);
                                                        // Rule at src/opts/icmp.isle line 144.
                                                        returns.extend(Some(v1473));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                    let v1483 = C::ty_smax(ctx, v161.0);
                                                    let v1484 = C::u64_eq(ctx, v212, v1483);
                                                    if v1484 == true {
                                                        let v1477 = constructor_iconst_u(ctx, v1472, 0x1_u64);
                                                        let v1478 = C::subsume(ctx, v1477);
                                                        // Rule at src/opts/icmp.isle line 164.
                                                        returns.extend(Some(v1478));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                            if v150.0 == v150.1 {
                                let v290 = constructor_cmp_true(ctx, v2.0);
                                let v1417 = C::subsume(ctx, v290);
                                // Rule at src/opts/icmp.isle line 13.
                                returns.extend(Some(v1417));
                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                            }
                            let mut v1372 = C::inst_data_value_tupled_etor_returns::default();
                            C::inst_data_value_tupled_etor(ctx, v150.1, &mut v1372);
                            let mut v1372 = v1372.into_context_iter();
                            while let Some(v1373) = v1372.next(ctx) {
                                let v1374 = C::iconst_sextend_etor(ctx, v1373);
                                if let Some(v1375) = v1374 {
                                    if v1375.1 == -1_i64 {
                                        let v1495 = constructor_iconst_s(ctx, v1375.0, 0_i64);
                                        let v1499 = constructor_slt(ctx, v2.0, v150.0, v1495);
                                        // Rule at src/opts/icmp.isle line 204.
                                        returns.extend(Some(v1499));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                            }
                        }
                        &IntCC::UnsignedGreaterThan => {
                            let v334 = C::fits_in_64(ctx, v2.0);
                            if let Some(v335) = v334 {
                                let v1471 = C::ty_int(ctx, v335);
                                if let Some(v1472) = v1471 {
                                    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 v1474 = constructor_ne(ctx, v1472, v150.0, v150.1);
                                                    // Rule at src/opts/icmp.isle line 111.
                                                    returns.extend(Some(v1474));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let v1475 = C::ty_umax(ctx, v161.0);
                                                let v1476 = C::u64_eq(ctx, v212, v1475);
                                                if v1476 == true {
                                                    let v1479 = constructor_iconst_u(ctx, v1472, 0x0_u64);
                                                    let v1480 = C::subsume(ctx, v1479);
                                                    // Rule at src/opts/icmp.isle line 129.
                                                    returns.extend(Some(v1480));
                                                    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 v1726 = constructor_iconst_u(ctx, v335, 0x0_u64);
                                                // Rule at src/opts/selects.isle line 109.
                                                returns.extend(Some(v1726));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            if v150.1 == v200.1 {
                                                let v1726 = constructor_iconst_u(ctx, v335, 0x0_u64);
                                                // Rule at src/opts/selects.isle line 110.
                                                returns.extend(Some(v1726));
                                                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; }
                                            }
                                        }
                                    }
                                }
                            }
                            if v150.0 == v150.1 {
                                let v53 = constructor_iconst_u(ctx, v2.0, 0x0_u64);
                                let v54 = C::subsume(ctx, v53);
                                // Rule at src/opts/icmp.isle line 6.
                                returns.extend(Some(v54));
                                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 v1543 = constructor_ugt(ctx, v2.0, v200.1, v200.0);
                                            // Rule at src/opts/icmp.isle line 298.
                                            returns.extend(Some(v1543));
                                            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 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 v212 = C::u64_from_imm64(ctx, v211);
                                            match v212 {
                                                0x0_u64 => {
                                                    let v290 = constructor_cmp_true(ctx, v2.0);
                                                    let v1417 = C::subsume(ctx, v290);
                                                    // Rule at src/opts/icmp.isle line 115.
                                                    returns.extend(Some(v1417));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                0x1_u64 => {
                                                    let v293 = constructor_iconst_u(ctx, v161.0, 0x0_u64);
                                                    let v1493 = constructor_ne(ctx, v2.0, v150.0, v293);
                                                    // Rule at src/opts/icmp.isle line 189.
                                                    returns.extend(Some(v1493));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                _ => {}
                                            }
                                            let v334 = C::fits_in_64(ctx, v2.0);
                                            if let Some(v335) = v334 {
                                                let v1471 = C::ty_int(ctx, v335);
                                                if let Some(v1472) = v1471 {
                                                    let v1475 = C::ty_umax(ctx, v161.0);
                                                    let v1476 = C::u64_eq(ctx, v212, v1475);
                                                    if v1476 == true {
                                                        let v1473 = constructor_eq(ctx, v1472, v150.0, v150.1);
                                                        // Rule at src/opts/icmp.isle line 134.
                                                        returns.extend(Some(v1473));
                                                        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 711.
                                                    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 712.
                                                    returns.extend(Some(v290));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                            }
                            if v150.0 == v150.1 {
                                let v290 = constructor_cmp_true(ctx, v2.0);
                                let v1417 = C::subsume(ctx, v290);
                                // Rule at src/opts/icmp.isle line 7.
                                returns.extend(Some(v1417));
                                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 v1726 = constructor_iconst_u(ctx, v335, 0x0_u64);
                                                    // Rule at src/opts/selects.isle line 111.
                                                    returns.extend(Some(v1726));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v150.0 == v166.1 {
                                                    let v1726 = constructor_iconst_u(ctx, v335, 0x0_u64);
                                                    // Rule at src/opts/selects.isle line 112.
                                                    returns.extend(Some(v1726));
                                                    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 v1563 = constructor_ugt(ctx, v2.0, v300, v302);
                                                            // Rule at src/opts/icmp.isle line 305.
                                                            returns.extend(Some(v1563));
                                                            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 v1494 = constructor_eq(ctx, v2.0, v150.0, v293);
                                                    // Rule at src/opts/icmp.isle line 192.
                                                    returns.extend(Some(v1494));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                _ => {}
                                            }
                                            let v334 = C::fits_in_64(ctx, v2.0);
                                            if let Some(v335) = v334 {
                                                let v1471 = C::ty_int(ctx, v335);
                                                if let Some(v1472) = v1471 {
                                                    let v1475 = C::ty_umax(ctx, v161.0);
                                                    let v1476 = C::u64_eq(ctx, v212, v1475);
                                                    if v1476 == true {
                                                        let v1474 = constructor_ne(ctx, v1472, v150.0, v150.1);
                                                        // Rule at src/opts/icmp.isle line 119.
                                                        returns.extend(Some(v1474));
                                                        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 v53 = constructor_iconst_u(ctx, v2.0, 0x0_u64);
                                let v54 = C::subsume(ctx, v53);
                                // Rule at src/opts/icmp.isle line 10.
                                returns.extend(Some(v54));
                                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 713.
                                                        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 714.
                                                        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 v1471 = C::ty_int(ctx, v335);
                                                if let Some(v1472) = v1471 {
                                                    let v212 = C::u64_from_imm64(ctx, v211);
                                                    if v212 == 0x0_u64 {
                                                        let v1473 = constructor_eq(ctx, v1472, v150.0, v150.1);
                                                        // Rule at src/opts/icmp.isle line 107.
                                                        returns.extend(Some(v1473));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                    let v1475 = C::ty_umax(ctx, v161.0);
                                                    let v1476 = C::u64_eq(ctx, v212, v1475);
                                                    if v1476 == true {
                                                        let v1477 = constructor_iconst_u(ctx, v1472, 0x1_u64);
                                                        let v1478 = C::subsume(ctx, v1477);
                                                        // Rule at src/opts/icmp.isle line 124.
                                                        returns.extend(Some(v1478));
                                                        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 v1544 = constructor_ule(ctx, v2.0, v200.1, v200.0);
                                                // Rule at src/opts/icmp.isle line 299.
                                                returns.extend(Some(v1544));
                                                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 707.
                                                    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 708.
                                                    returns.extend(Some(v290));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                            }
                            if v150.0 == v150.1 {
                                let v290 = constructor_cmp_true(ctx, v2.0);
                                let v1417 = C::subsume(ctx, v290);
                                // Rule at src/opts/icmp.isle line 11.
                                returns.extend(Some(v1417));
                                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 v1382 = &C::signed_cond_code(ctx, v149);
                                    if let Some(v1383) = v1382 {
                                        let mut v1372 = C::inst_data_value_tupled_etor_returns::default();
                                        C::inst_data_value_tupled_etor(ctx, v150.1, &mut v1372);
                                        let mut v1372 = v1372.into_context_iter();
                                        while let Some(v1373) = v1372.next(ctx) {
                                            let v1374 = C::iconst_sextend_etor(ctx, v1373);
                                            if let Some(v1375) = v1374 {
                                                if v1375.1 == 0_i64 {
                                                    let v1370 = C::value_type(ctx, v300);
                                                    let v1379 = constructor_iconst_s(ctx, v1370, 0_i64);
                                                    let v1384 = constructor_icmp(ctx, v1370, v149, v300, v1379);
                                                    // Rule at src/opts/extends.isle line 43.
                                                    returns.extend(Some(v1384));
                                                    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 v1025 = C::imm64_icmp(ctx, v154.0, v149, v158, v211);
                                                    let v1026 = constructor_iconst(ctx, v2.0, v1025);
                                                    let v1027 = C::subsume(ctx, v1026);
                                                    // Rule at src/opts/cprop.isle line 134.
                                                    returns.extend(Some(v1027));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                    let v1039 = &C::intcc_swap_args(ctx, v149);
                                    let v1040 = constructor_icmp(ctx, v2.0, v1039, v150.1, v150.0);
                                    // Rule at src/opts/cprop.isle line 173.
                                    returns.extend(Some(v1040));
                                    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 v1729,
                                    args: ref v1730,
                                } => {
                                    if let &Opcode::Bor = v1729 {
                                        let v1731 = C::unpack_value_array_2(ctx, v1730);
                                        let mut v1734 = C::inst_data_value_etor_returns::default();
                                        C::inst_data_value_etor(ctx, v1731.1, &mut v1734);
                                        let mut v1734 = v1734.into_context_iter();
                                        while let Some(v1735) = v1734.next(ctx) {
                                            if let &InstructionData::IntCompare {
                                                opcode: ref v1738,
                                                args: ref v1739,
                                                cond: ref v1740,
                                            } = &v1735.1 {
                                                if let &Opcode::Icmp = v1738 {
                                                    if let &IntCC::NotEqual = v1740 {
                                                        if v84.0 == v1735.0 {
                                                            let v1741 = C::unpack_value_array_2(ctx, v1739);
                                                            if v79.1 == v1741.0 {
                                                                if v79.2 == v1741.1 {
                                                                    let v1744 = C::subsume(ctx, v1741.0);
                                                                    // Rule at src/opts/selects.isle line 122.
                                                                    returns.extend(Some(v1744));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                            if v79.1 == v1741.1 {
                                                                if v79.2 == v1741.0 {
                                                                    let v1756 = C::subsume(ctx, v1741.1);
                                                                    // Rule at src/opts/selects.isle line 124.
                                                                    returns.extend(Some(v1756));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        let mut v1745 = C::inst_data_value_etor_returns::default();
                                        C::inst_data_value_etor(ctx, v1731.0, &mut v1745);
                                        let mut v1745 = v1745.into_context_iter();
                                        while let Some(v1746) = v1745.next(ctx) {
                                            if let &InstructionData::IntCompare {
                                                opcode: ref v1749,
                                                args: ref v1750,
                                                cond: ref v1751,
                                            } = &v1746.1 {
                                                if let &Opcode::Icmp = v1749 {
                                                    if let &IntCC::NotEqual = v1751 {
                                                        if v84.0 == v1746.0 {
                                                            let v1752 = C::unpack_value_array_2(ctx, v1750);
                                                            if v79.1 == v1752.0 {
                                                                if v79.2 == v1752.1 {
                                                                    let v1755 = C::subsume(ctx, v1752.0);
                                                                    // Rule at src/opts/selects.isle line 123.
                                                                    returns.extend(Some(v1755));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                            if v79.1 == v1752.1 {
                                                                if v79.2 == v1752.0 {
                                                                    let v1757 = C::subsume(ctx, v1752.1);
                                                                    // Rule at src/opts/selects.isle line 125.
                                                                    returns.extend(Some(v1757));
                                                                    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::Equal => {
                                                let mut v1516 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v79.2, &mut v1516);
                                                let mut v1516 = v1516.into_context_iter();
                                                while let Some(v1517) = v1516.next(ctx) {
                                                    match &v1517.1 {
                                                        &InstructionData::Binary {
                                                            opcode: ref v1758,
                                                            args: ref v1759,
                                                        } => {
                                                            match v1758 {
                                                                &Opcode::Isub => {
                                                                    if v2.0 == v1517.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 v1764,
                                                                                args: ref v1765,
                                                                            } = &v90.1 {
                                                                                if let &Opcode::Isub = v1764 {
                                                                                    if v2.0 == v90.0 {
                                                                                        let v1760 = C::unpack_value_array_2(ctx, v1759);
                                                                                        let v1766 = C::unpack_value_array_2(ctx, v1765);
                                                                                        if v1760.0 == v1766.0 {
                                                                                            let mut v1778 = C::inst_data_value_etor_returns::default();
                                                                                            C::inst_data_value_etor(ctx, v1766.1, &mut v1778);
                                                                                            let mut v1778 = v1778.into_context_iter();
                                                                                            while let Some(v1779) = v1778.next(ctx) {
                                                                                                if let &InstructionData::UnaryImm {
                                                                                                    opcode: ref v1782,
                                                                                                    imm: v1783,
                                                                                                } = &v1779.1 {
                                                                                                    if let &Opcode::Iconst = v1782 {
                                                                                                        if v2.0 == v1779.0 {
                                                                                                            let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                                                            if v1503.0 == v1760.1 {
                                                                                                                let mut v1680 = C::inst_data_value_etor_returns::default();
                                                                                                                C::inst_data_value_etor(ctx, v1503.1, &mut v1680);
                                                                                                                let mut v1680 = v1680.into_context_iter();
                                                                                                                while let Some(v1681) = v1680.next(ctx) {
                                                                                                                    if let &InstructionData::UnaryImm {
                                                                                                                        opcode: ref v1684,
                                                                                                                        imm: v1685,
                                                                                                                    } = &v1681.1 {
                                                                                                                        if let &Opcode::Iconst = v1684 {
                                                                                                                            if v2.0 == v1681.0 {
                                                                                                                                let v1686 = C::u64_from_imm64(ctx, v1685);
                                                                                                                                let v1784 = C::u64_from_imm64(ctx, v1783);
                                                                                                                                if v1686 == v1784 {
                                                                                                                                    let v1785 = constructor_isub(ctx, v2.0, v1766.0, v1503.0);
                                                                                                                                    // Rule at src/opts/selects.isle line 185.
                                                                                                                                    returns.extend(Some(v1785));
                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                            if v1503.1 == v1760.1 {
                                                                                                                let mut v1793 = C::inst_data_value_etor_returns::default();
                                                                                                                C::inst_data_value_etor(ctx, v1503.0, &mut v1793);
                                                                                                                let mut v1793 = v1793.into_context_iter();
                                                                                                                while let Some(v1794) = v1793.next(ctx) {
                                                                                                                    if let &InstructionData::UnaryImm {
                                                                                                                        opcode: ref v1797,
                                                                                                                        imm: v1798,
                                                                                                                    } = &v1794.1 {
                                                                                                                        if let &Opcode::Iconst = v1797 {
                                                                                                                            if v2.0 == v1794.0 {
                                                                                                                                let v1784 = C::u64_from_imm64(ctx, v1783);
                                                                                                                                let v1799 = C::u64_from_imm64(ctx, v1798);
                                                                                                                                if v1784 == v1799 {
                                                                                                                                    let v1800 = constructor_isub(ctx, v2.0, v1766.0, v1503.1);
                                                                                                                                    // Rule at src/opts/selects.isle line 187.
                                                                                                                                    returns.extend(Some(v1800));
                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Band => {
                                                                    if v2.0 == v1517.0 {
                                                                        let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                        if v79.1 == v1503.0 {
                                                                            let v1760 = C::unpack_value_array_2(ctx, v1759);
                                                                            if v79.1 == v1760.0 {
                                                                                if v1503.1 == v1760.1 {
                                                                                    let v1771 = constructor_band(ctx, v2.0, v1503.1, v1503.0);
                                                                                    // Rule at src/opts/selects.isle line 147.
                                                                                    returns.extend(Some(v1771));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                            if v79.1 == v1760.1 {
                                                                                if v1503.1 == v1760.0 {
                                                                                    let v1771 = constructor_band(ctx, v2.0, v1503.1, v1503.0);
                                                                                    // Rule at src/opts/selects.isle line 145.
                                                                                    returns.extend(Some(v1771));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                        if v79.1 == v1503.1 {
                                                                            let v1760 = C::unpack_value_array_2(ctx, v1759);
                                                                            if v79.1 == v1760.0 {
                                                                                if v1503.0 == v1760.1 {
                                                                                    let v1770 = constructor_band(ctx, v2.0, v1503.0, v1503.1);
                                                                                    // Rule at src/opts/selects.isle line 143.
                                                                                    returns.extend(Some(v1770));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                            if v1503.0 == v1760.0 {
                                                                                if v79.1 == v1760.1 {
                                                                                    let v1770 = constructor_band(ctx, v2.0, v1503.0, v1503.1);
                                                                                    // Rule at src/opts/selects.isle line 141.
                                                                                    returns.extend(Some(v1770));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Bor => {
                                                                    if v2.0 == v1517.0 {
                                                                        let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                        if v79.1 == v1503.0 {
                                                                            let v1760 = C::unpack_value_array_2(ctx, v1759);
                                                                            if v79.1 == v1760.0 {
                                                                                if v1503.1 == v1760.1 {
                                                                                    let v1763 = constructor_bor(ctx, v2.0, v1503.0, v1503.1);
                                                                                    // Rule at src/opts/selects.isle line 129.
                                                                                    returns.extend(Some(v1763));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                            if v79.1 == v1760.1 {
                                                                                if v1503.1 == v1760.0 {
                                                                                    let v1763 = constructor_bor(ctx, v2.0, v1503.0, v1503.1);
                                                                                    // Rule at src/opts/selects.isle line 131.
                                                                                    returns.extend(Some(v1763));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                        if v79.1 == v1503.1 {
                                                                            let v1760 = C::unpack_value_array_2(ctx, v1759);
                                                                            if v79.1 == v1760.0 {
                                                                                if v1503.0 == v1760.1 {
                                                                                    let v1769 = constructor_bor(ctx, v2.0, v1503.1, v1503.0);
                                                                                    // Rule at src/opts/selects.isle line 133.
                                                                                    returns.extend(Some(v1769));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                            if v1503.0 == v1760.0 {
                                                                                if v79.1 == v1760.1 {
                                                                                    let v1769 = constructor_bor(ctx, v2.0, v1503.1, v1503.0);
                                                                                    // Rule at src/opts/selects.isle line 135.
                                                                                    returns.extend(Some(v1769));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                        &InstructionData::IntCompare {
                                                            opcode: ref v1520,
                                                            args: ref v1521,
                                                            cond: ref v1522,
                                                        } => {
                                                            if let &Opcode::Icmp = v1520 {
                                                                match v1522 {
                                                                    &IntCC::SignedGreaterThan => {
                                                                        let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                        let v1506 = C::value_type(ctx, v1503.0);
                                                                        if v1506 == I64 {
                                                                            let v1507 = C::value_type(ctx, v1503.1);
                                                                            if v1507 == I64 {
                                                                                if v2.0 == v1517.0 {
                                                                                    let v1523 = C::unpack_value_array_2(ctx, v1521);
                                                                                    if v1503.0 == v1523.0 {
                                                                                        if v1503.1 == v1523.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 v1508,
                                                                                                    args: ref v1509,
                                                                                                    cond: ref v1510,
                                                                                                } = &v90.1 {
                                                                                                    if let &Opcode::Icmp = v1508 {
                                                                                                        if let &IntCC::UnsignedGreaterThan = v1510 {
                                                                                                            let v1511 = C::unpack_value_array_2(ctx, v1509);
                                                                                                            let v1514 = C::value_type(ctx, v1511.0);
                                                                                                            if v1514 == I64 {
                                                                                                                let v1515 = C::value_type(ctx, v1511.1);
                                                                                                                if v1515 == I64 {
                                                                                                                    if v2.0 == v90.0 {
                                                                                                                        let v1526 = constructor_iconcat(ctx, I64, v1511.0, v1503.0);
                                                                                                                        let v1527 = constructor_iconcat(ctx, I64, v1511.1, v1503.1);
                                                                                                                        let v1531 = constructor_sgt(ctx, v2.0, v1526, v1527);
                                                                                                                        // Rule at src/opts/icmp.isle line 268.
                                                                                                                        returns.extend(Some(v1531));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedGreaterThanOrEqual => {
                                                                        let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                        let v1506 = C::value_type(ctx, v1503.0);
                                                                        if v1506 == I64 {
                                                                            let v1507 = C::value_type(ctx, v1503.1);
                                                                            if v1507 == I64 {
                                                                                if v2.0 == v1517.0 {
                                                                                    let v1523 = C::unpack_value_array_2(ctx, v1521);
                                                                                    if v1503.0 == v1523.0 {
                                                                                        if v1503.1 == v1523.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 v1508,
                                                                                                    args: ref v1509,
                                                                                                    cond: ref v1510,
                                                                                                } = &v90.1 {
                                                                                                    if let &Opcode::Icmp = v1508 {
                                                                                                        if let &IntCC::UnsignedGreaterThanOrEqual = v1510 {
                                                                                                            let v1511 = C::unpack_value_array_2(ctx, v1509);
                                                                                                            let v1514 = C::value_type(ctx, v1511.0);
                                                                                                            if v1514 == I64 {
                                                                                                                let v1515 = C::value_type(ctx, v1511.1);
                                                                                                                if v1515 == I64 {
                                                                                                                    if v2.0 == v90.0 {
                                                                                                                        let v1526 = constructor_iconcat(ctx, I64, v1511.0, v1503.0);
                                                                                                                        let v1527 = constructor_iconcat(ctx, I64, v1511.1, v1503.1);
                                                                                                                        let v1529 = constructor_sge(ctx, v2.0, v1526, v1527);
                                                                                                                        // Rule at src/opts/icmp.isle line 258.
                                                                                                                        returns.extend(Some(v1529));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedLessThan => {
                                                                        let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                        let v1506 = C::value_type(ctx, v1503.0);
                                                                        if v1506 == I64 {
                                                                            let v1507 = C::value_type(ctx, v1503.1);
                                                                            if v1507 == I64 {
                                                                                if v2.0 == v1517.0 {
                                                                                    let v1523 = C::unpack_value_array_2(ctx, v1521);
                                                                                    if v1503.0 == v1523.0 {
                                                                                        if v1503.1 == v1523.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 v1508,
                                                                                                    args: ref v1509,
                                                                                                    cond: ref v1510,
                                                                                                } = &v90.1 {
                                                                                                    if let &Opcode::Icmp = v1508 {
                                                                                                        if let &IntCC::UnsignedLessThan = v1510 {
                                                                                                            let v1511 = C::unpack_value_array_2(ctx, v1509);
                                                                                                            let v1514 = C::value_type(ctx, v1511.0);
                                                                                                            if v1514 == I64 {
                                                                                                                let v1515 = C::value_type(ctx, v1511.1);
                                                                                                                if v1515 == I64 {
                                                                                                                    if v2.0 == v90.0 {
                                                                                                                        let v1526 = constructor_iconcat(ctx, I64, v1511.0, v1503.0);
                                                                                                                        let v1527 = constructor_iconcat(ctx, I64, v1511.1, v1503.1);
                                                                                                                        let v1535 = constructor_slt(ctx, v2.0, v1526, v1527);
                                                                                                                        // Rule at src/opts/icmp.isle line 288.
                                                                                                                        returns.extend(Some(v1535));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedLessThanOrEqual => {
                                                                        let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                        let v1506 = C::value_type(ctx, v1503.0);
                                                                        if v1506 == I64 {
                                                                            let v1507 = C::value_type(ctx, v1503.1);
                                                                            if v1507 == I64 {
                                                                                if v2.0 == v1517.0 {
                                                                                    let v1523 = C::unpack_value_array_2(ctx, v1521);
                                                                                    if v1503.0 == v1523.0 {
                                                                                        if v1503.1 == v1523.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 v1508,
                                                                                                    args: ref v1509,
                                                                                                    cond: ref v1510,
                                                                                                } = &v90.1 {
                                                                                                    if let &Opcode::Icmp = v1508 {
                                                                                                        if let &IntCC::UnsignedLessThanOrEqual = v1510 {
                                                                                                            let v1511 = C::unpack_value_array_2(ctx, v1509);
                                                                                                            let v1514 = C::value_type(ctx, v1511.0);
                                                                                                            if v1514 == I64 {
                                                                                                                let v1515 = C::value_type(ctx, v1511.1);
                                                                                                                if v1515 == I64 {
                                                                                                                    if v2.0 == v90.0 {
                                                                                                                        let v1526 = constructor_iconcat(ctx, I64, v1511.0, v1503.0);
                                                                                                                        let v1527 = constructor_iconcat(ctx, I64, v1511.1, v1503.1);
                                                                                                                        let v1533 = constructor_sle(ctx, v2.0, v1526, v1527);
                                                                                                                        // Rule at src/opts/icmp.isle line 278.
                                                                                                                        returns.extend(Some(v1533));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedGreaterThan => {
                                                                        let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                        let v1506 = C::value_type(ctx, v1503.0);
                                                                        if v1506 == I64 {
                                                                            let v1507 = C::value_type(ctx, v1503.1);
                                                                            if v1507 == I64 {
                                                                                if v2.0 == v1517.0 {
                                                                                    let v1523 = C::unpack_value_array_2(ctx, v1521);
                                                                                    if v1503.0 == v1523.0 {
                                                                                        if v1503.1 == v1523.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 v1508,
                                                                                                    args: ref v1509,
                                                                                                    cond: ref v1510,
                                                                                                } = &v90.1 {
                                                                                                    if let &Opcode::Icmp = v1508 {
                                                                                                        if let &IntCC::UnsignedGreaterThan = v1510 {
                                                                                                            let v1511 = C::unpack_value_array_2(ctx, v1509);
                                                                                                            let v1514 = C::value_type(ctx, v1511.0);
                                                                                                            if v1514 == I64 {
                                                                                                                let v1515 = C::value_type(ctx, v1511.1);
                                                                                                                if v1515 == I64 {
                                                                                                                    if v2.0 == v90.0 {
                                                                                                                        let v1526 = constructor_iconcat(ctx, I64, v1511.0, v1503.0);
                                                                                                                        let v1527 = constructor_iconcat(ctx, I64, v1511.1, v1503.1);
                                                                                                                        let v1530 = constructor_ugt(ctx, v2.0, v1526, v1527);
                                                                                                                        // Rule at src/opts/icmp.isle line 263.
                                                                                                                        returns.extend(Some(v1530));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedGreaterThanOrEqual => {
                                                                        let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                        let v1506 = C::value_type(ctx, v1503.0);
                                                                        if v1506 == I64 {
                                                                            let v1507 = C::value_type(ctx, v1503.1);
                                                                            if v1507 == I64 {
                                                                                if v2.0 == v1517.0 {
                                                                                    let v1523 = C::unpack_value_array_2(ctx, v1521);
                                                                                    if v1503.0 == v1523.0 {
                                                                                        if v1503.1 == v1523.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 v1508,
                                                                                                    args: ref v1509,
                                                                                                    cond: ref v1510,
                                                                                                } = &v90.1 {
                                                                                                    if let &Opcode::Icmp = v1508 {
                                                                                                        if let &IntCC::UnsignedGreaterThanOrEqual = v1510 {
                                                                                                            let v1511 = C::unpack_value_array_2(ctx, v1509);
                                                                                                            let v1514 = C::value_type(ctx, v1511.0);
                                                                                                            if v1514 == I64 {
                                                                                                                let v1515 = C::value_type(ctx, v1511.1);
                                                                                                                if v1515 == I64 {
                                                                                                                    if v2.0 == v90.0 {
                                                                                                                        let v1526 = constructor_iconcat(ctx, I64, v1511.0, v1503.0);
                                                                                                                        let v1527 = constructor_iconcat(ctx, I64, v1511.1, v1503.1);
                                                                                                                        let v1528 = constructor_uge(ctx, v2.0, v1526, v1527);
                                                                                                                        // Rule at src/opts/icmp.isle line 253.
                                                                                                                        returns.extend(Some(v1528));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                        let v1506 = C::value_type(ctx, v1503.0);
                                                                        if v1506 == I64 {
                                                                            let v1507 = C::value_type(ctx, v1503.1);
                                                                            if v1507 == I64 {
                                                                                if v2.0 == v1517.0 {
                                                                                    let v1523 = C::unpack_value_array_2(ctx, v1521);
                                                                                    if v1503.0 == v1523.0 {
                                                                                        if v1503.1 == v1523.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 v1508,
                                                                                                    args: ref v1509,
                                                                                                    cond: ref v1510,
                                                                                                } = &v90.1 {
                                                                                                    if let &Opcode::Icmp = v1508 {
                                                                                                        if let &IntCC::UnsignedLessThan = v1510 {
                                                                                                            let v1511 = C::unpack_value_array_2(ctx, v1509);
                                                                                                            let v1514 = C::value_type(ctx, v1511.0);
                                                                                                            if v1514 == I64 {
                                                                                                                let v1515 = C::value_type(ctx, v1511.1);
                                                                                                                if v1515 == I64 {
                                                                                                                    if v2.0 == v90.0 {
                                                                                                                        let v1526 = constructor_iconcat(ctx, I64, v1511.0, v1503.0);
                                                                                                                        let v1527 = constructor_iconcat(ctx, I64, v1511.1, v1503.1);
                                                                                                                        let v1534 = constructor_ult(ctx, v2.0, v1526, v1527);
                                                                                                                        // Rule at src/opts/icmp.isle line 283.
                                                                                                                        returns.extend(Some(v1534));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThanOrEqual => {
                                                                        let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                        let v1506 = C::value_type(ctx, v1503.0);
                                                                        if v1506 == I64 {
                                                                            let v1507 = C::value_type(ctx, v1503.1);
                                                                            if v1507 == I64 {
                                                                                if v2.0 == v1517.0 {
                                                                                    let v1523 = C::unpack_value_array_2(ctx, v1521);
                                                                                    if v1503.0 == v1523.0 {
                                                                                        if v1503.1 == v1523.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 v1508,
                                                                                                    args: ref v1509,
                                                                                                    cond: ref v1510,
                                                                                                } = &v90.1 {
                                                                                                    if let &Opcode::Icmp = v1508 {
                                                                                                        if let &IntCC::UnsignedLessThanOrEqual = v1510 {
                                                                                                            let v1511 = C::unpack_value_array_2(ctx, v1509);
                                                                                                            let v1514 = C::value_type(ctx, v1511.0);
                                                                                                            if v1514 == I64 {
                                                                                                                let v1515 = C::value_type(ctx, v1511.1);
                                                                                                                if v1515 == I64 {
                                                                                                                    if v2.0 == v90.0 {
                                                                                                                        let v1526 = constructor_iconcat(ctx, I64, v1511.0, v1503.0);
                                                                                                                        let v1527 = constructor_iconcat(ctx, I64, v1511.1, v1503.1);
                                                                                                                        let v1532 = constructor_ule(ctx, v2.0, v1526, v1527);
                                                                                                                        // Rule at src/opts/icmp.isle line 273.
                                                                                                                        returns.extend(Some(v1532));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::Ternary {
                                                            opcode: ref v1712,
                                                            args: ref v1713,
                                                        } => {
                                                            if let &Opcode::Select = v1712 {
                                                                if v2.0 == v1517.0 {
                                                                    let mut v1644 = C::inst_data_value_tupled_etor_returns::default();
                                                                    C::inst_data_value_tupled_etor(ctx, v79.1, &mut v1644);
                                                                    let mut v1644 = v1644.into_context_iter();
                                                                    while let Some(v1645) = v1644.next(ctx) {
                                                                        let v1646 = C::iconst_sextend_etor(ctx, v1645);
                                                                        if let Some(v1647) = v1646 {
                                                                            if v1647.1 == 0_i64 {
                                                                                if v2.0 == v1647.0 {
                                                                                    let v1714 = C::unpack_value_array_3(ctx, v1713);
                                                                                    let mut v1946 = C::inst_data_value_etor_returns::default();
                                                                                    C::inst_data_value_etor(ctx, v1714.0, &mut v1946);
                                                                                    let mut v1946 = v1946.into_context_iter();
                                                                                    while let Some(v1947) = v1946.next(ctx) {
                                                                                        if let &InstructionData::IntCompare {
                                                                                            opcode: ref v1950,
                                                                                            args: ref v1951,
                                                                                            cond: ref v1952,
                                                                                        } = &v1947.1 {
                                                                                            if let &Opcode::Icmp = v1950 {
                                                                                                match v1952 {
                                                                                                    &IntCC::SignedGreaterThan => {
                                                                                                        if v84.0 == v1947.0 {
                                                                                                            let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                                                            let v1953 = C::unpack_value_array_2(ctx, v1951);
                                                                                                            if v1503.0 == v1953.0 {
                                                                                                                if v1503.1 == v1953.1 {
                                                                                                                    let mut v1956 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1714.1, &mut v1956);
                                                                                                                    let mut v1956 = v1956.into_context_iter();
                                                                                                                    while let Some(v1957) = v1956.next(ctx) {
                                                                                                                        let v1958 = C::iconst_sextend_etor(ctx, v1957);
                                                                                                                        if let Some(v1959) = v1958 {
                                                                                                                            if v1959.1 == 1_i64 {
                                                                                                                                if v2.0 == v1959.0 {
                                                                                                                                    let mut v1962 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1714.2, &mut v1962);
                                                                                                                                    let mut v1962 = v1962.into_context_iter();
                                                                                                                                    while let Some(v1963) = v1962.next(ctx) {
                                                                                                                                        let v1964 = C::iconst_sextend_etor(ctx, v1963);
                                                                                                                                        if let Some(v1965) = v1964 {
                                                                                                                                            if v1965.1 == -1_i64 {
                                                                                                                                                if v2.0 == v1965.0 {
                                                                                                                                                    let v1978 = constructor_spaceship_s(ctx, v84.0, v1503.0, v1503.1);
                                                                                                                                                    let v1979 = constructor_sextend_maybe(ctx, v2.0, v1978);
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 103.
                                                                                                                                                    returns.extend(Some(v1979));
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    &IntCC::SignedGreaterThanOrEqual => {
                                                                                                        if v84.0 == v1947.0 {
                                                                                                            let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                                                            let v1953 = C::unpack_value_array_2(ctx, v1951);
                                                                                                            if v1503.0 == v1953.0 {
                                                                                                                if v1503.1 == v1953.1 {
                                                                                                                    let mut v1956 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1714.1, &mut v1956);
                                                                                                                    let mut v1956 = v1956.into_context_iter();
                                                                                                                    while let Some(v1957) = v1956.next(ctx) {
                                                                                                                        let v1958 = C::iconst_sextend_etor(ctx, v1957);
                                                                                                                        if let Some(v1959) = v1958 {
                                                                                                                            if v1959.1 == 1_i64 {
                                                                                                                                if v2.0 == v1959.0 {
                                                                                                                                    let mut v1962 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1714.2, &mut v1962);
                                                                                                                                    let mut v1962 = v1962.into_context_iter();
                                                                                                                                    while let Some(v1963) = v1962.next(ctx) {
                                                                                                                                        let v1964 = C::iconst_sextend_etor(ctx, v1963);
                                                                                                                                        if let Some(v1965) = v1964 {
                                                                                                                                            if v1965.1 == -1_i64 {
                                                                                                                                                if v2.0 == v1965.0 {
                                                                                                                                                    let v1978 = constructor_spaceship_s(ctx, v84.0, v1503.0, v1503.1);
                                                                                                                                                    let v1979 = constructor_sextend_maybe(ctx, v2.0, v1978);
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 110.
                                                                                                                                                    returns.extend(Some(v1979));
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    &IntCC::SignedLessThan => {
                                                                                                        if v84.0 == v1947.0 {
                                                                                                            let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                                                            let v1953 = C::unpack_value_array_2(ctx, v1951);
                                                                                                            if v1503.0 == v1953.0 {
                                                                                                                if v1503.1 == v1953.1 {
                                                                                                                    let mut v1956 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1714.1, &mut v1956);
                                                                                                                    let mut v1956 = v1956.into_context_iter();
                                                                                                                    while let Some(v1957) = v1956.next(ctx) {
                                                                                                                        let v1958 = C::iconst_sextend_etor(ctx, v1957);
                                                                                                                        if let Some(v1959) = v1958 {
                                                                                                                            if v1959.1 == -1_i64 {
                                                                                                                                if v2.0 == v1959.0 {
                                                                                                                                    let mut v1962 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1714.2, &mut v1962);
                                                                                                                                    let mut v1962 = v1962.into_context_iter();
                                                                                                                                    while let Some(v1963) = v1962.next(ctx) {
                                                                                                                                        let v1964 = C::iconst_sextend_etor(ctx, v1963);
                                                                                                                                        if let Some(v1965) = v1964 {
                                                                                                                                            if v1965.1 == 1_i64 {
                                                                                                                                                if v2.0 == v1965.0 {
                                                                                                                                                    let v1978 = constructor_spaceship_s(ctx, v84.0, v1503.0, v1503.1);
                                                                                                                                                    let v1979 = constructor_sextend_maybe(ctx, v2.0, v1978);
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 89.
                                                                                                                                                    returns.extend(Some(v1979));
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    &IntCC::SignedLessThanOrEqual => {
                                                                                                        if v84.0 == v1947.0 {
                                                                                                            let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                                                            let v1953 = C::unpack_value_array_2(ctx, v1951);
                                                                                                            if v1503.0 == v1953.0 {
                                                                                                                if v1503.1 == v1953.1 {
                                                                                                                    let mut v1956 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1714.1, &mut v1956);
                                                                                                                    let mut v1956 = v1956.into_context_iter();
                                                                                                                    while let Some(v1957) = v1956.next(ctx) {
                                                                                                                        let v1958 = C::iconst_sextend_etor(ctx, v1957);
                                                                                                                        if let Some(v1959) = v1958 {
                                                                                                                            if v1959.1 == -1_i64 {
                                                                                                                                if v2.0 == v1959.0 {
                                                                                                                                    let mut v1962 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1714.2, &mut v1962);
                                                                                                                                    let mut v1962 = v1962.into_context_iter();
                                                                                                                                    while let Some(v1963) = v1962.next(ctx) {
                                                                                                                                        let v1964 = C::iconst_sextend_etor(ctx, v1963);
                                                                                                                                        if let Some(v1965) = v1964 {
                                                                                                                                            if v1965.1 == 1_i64 {
                                                                                                                                                if v2.0 == v1965.0 {
                                                                                                                                                    let v1978 = constructor_spaceship_s(ctx, v84.0, v1503.0, v1503.1);
                                                                                                                                                    let v1979 = constructor_sextend_maybe(ctx, v2.0, v1978);
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 96.
                                                                                                                                                    returns.extend(Some(v1979));
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    &IntCC::UnsignedGreaterThan => {
                                                                                                        if v84.0 == v1947.0 {
                                                                                                            let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                                                            let v1953 = C::unpack_value_array_2(ctx, v1951);
                                                                                                            if v1503.0 == v1953.0 {
                                                                                                                if v1503.1 == v1953.1 {
                                                                                                                    let mut v1956 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1714.1, &mut v1956);
                                                                                                                    let mut v1956 = v1956.into_context_iter();
                                                                                                                    while let Some(v1957) = v1956.next(ctx) {
                                                                                                                        let v1958 = C::iconst_sextend_etor(ctx, v1957);
                                                                                                                        if let Some(v1959) = v1958 {
                                                                                                                            if v1959.1 == 1_i64 {
                                                                                                                                if v2.0 == v1959.0 {
                                                                                                                                    let mut v1962 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1714.2, &mut v1962);
                                                                                                                                    let mut v1962 = v1962.into_context_iter();
                                                                                                                                    while let Some(v1963) = v1962.next(ctx) {
                                                                                                                                        let v1964 = C::iconst_sextend_etor(ctx, v1963);
                                                                                                                                        if let Some(v1965) = v1964 {
                                                                                                                                            if v1965.1 == -1_i64 {
                                                                                                                                                if v2.0 == v1965.0 {
                                                                                                                                                    let v1944 = constructor_spaceship_u(ctx, v84.0, v1503.0, v1503.1);
                                                                                                                                                    let v1945 = constructor_sextend_maybe(ctx, v2.0, v1944);
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 38.
                                                                                                                                                    returns.extend(Some(v1945));
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    &IntCC::UnsignedGreaterThanOrEqual => {
                                                                                                        if v84.0 == v1947.0 {
                                                                                                            let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                                                            let v1953 = C::unpack_value_array_2(ctx, v1951);
                                                                                                            if v1503.0 == v1953.0 {
                                                                                                                if v1503.1 == v1953.1 {
                                                                                                                    let mut v1956 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1714.1, &mut v1956);
                                                                                                                    let mut v1956 = v1956.into_context_iter();
                                                                                                                    while let Some(v1957) = v1956.next(ctx) {
                                                                                                                        let v1958 = C::iconst_sextend_etor(ctx, v1957);
                                                                                                                        if let Some(v1959) = v1958 {
                                                                                                                            if v1959.1 == 1_i64 {
                                                                                                                                if v2.0 == v1959.0 {
                                                                                                                                    let mut v1962 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1714.2, &mut v1962);
                                                                                                                                    let mut v1962 = v1962.into_context_iter();
                                                                                                                                    while let Some(v1963) = v1962.next(ctx) {
                                                                                                                                        let v1964 = C::iconst_sextend_etor(ctx, v1963);
                                                                                                                                        if let Some(v1965) = v1964 {
                                                                                                                                            if v1965.1 == -1_i64 {
                                                                                                                                                if v2.0 == v1965.0 {
                                                                                                                                                    let v1944 = constructor_spaceship_u(ctx, v84.0, v1503.0, v1503.1);
                                                                                                                                                    let v1945 = constructor_sextend_maybe(ctx, v2.0, v1944);
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 45.
                                                                                                                                                    returns.extend(Some(v1945));
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    &IntCC::UnsignedLessThan => {
                                                                                                        if v84.0 == v1947.0 {
                                                                                                            let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                                                            let v1953 = C::unpack_value_array_2(ctx, v1951);
                                                                                                            if v1503.0 == v1953.0 {
                                                                                                                if v1503.1 == v1953.1 {
                                                                                                                    let mut v1956 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1714.1, &mut v1956);
                                                                                                                    let mut v1956 = v1956.into_context_iter();
                                                                                                                    while let Some(v1957) = v1956.next(ctx) {
                                                                                                                        let v1958 = C::iconst_sextend_etor(ctx, v1957);
                                                                                                                        if let Some(v1959) = v1958 {
                                                                                                                            if v1959.1 == -1_i64 {
                                                                                                                                if v2.0 == v1959.0 {
                                                                                                                                    let mut v1962 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1714.2, &mut v1962);
                                                                                                                                    let mut v1962 = v1962.into_context_iter();
                                                                                                                                    while let Some(v1963) = v1962.next(ctx) {
                                                                                                                                        let v1964 = C::iconst_sextend_etor(ctx, v1963);
                                                                                                                                        if let Some(v1965) = v1964 {
                                                                                                                                            if v1965.1 == 1_i64 {
                                                                                                                                                if v2.0 == v1965.0 {
                                                                                                                                                    let v1944 = constructor_spaceship_u(ctx, v84.0, v1503.0, v1503.1);
                                                                                                                                                    let v1945 = constructor_sextend_maybe(ctx, v2.0, v1944);
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 24.
                                                                                                                                                    returns.extend(Some(v1945));
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    &IntCC::UnsignedLessThanOrEqual => {
                                                                                                        if v84.0 == v1947.0 {
                                                                                                            let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                                                            let v1953 = C::unpack_value_array_2(ctx, v1951);
                                                                                                            if v1503.0 == v1953.0 {
                                                                                                                if v1503.1 == v1953.1 {
                                                                                                                    let mut v1956 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1714.1, &mut v1956);
                                                                                                                    let mut v1956 = v1956.into_context_iter();
                                                                                                                    while let Some(v1957) = v1956.next(ctx) {
                                                                                                                        let v1958 = C::iconst_sextend_etor(ctx, v1957);
                                                                                                                        if let Some(v1959) = v1958 {
                                                                                                                            if v1959.1 == -1_i64 {
                                                                                                                                if v2.0 == v1959.0 {
                                                                                                                                    let mut v1962 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1714.2, &mut v1962);
                                                                                                                                    let mut v1962 = v1962.into_context_iter();
                                                                                                                                    while let Some(v1963) = v1962.next(ctx) {
                                                                                                                                        let v1964 = C::iconst_sextend_etor(ctx, v1963);
                                                                                                                                        if let Some(v1965) = v1964 {
                                                                                                                                            if v1965.1 == 1_i64 {
                                                                                                                                                if v2.0 == v1965.0 {
                                                                                                                                                    let v1944 = constructor_spaceship_u(ctx, v84.0, v1503.0, v1503.1);
                                                                                                                                                    let v1945 = constructor_sextend_maybe(ctx, v2.0, v1944);
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 31.
                                                                                                                                                    returns.extend(Some(v1945));
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    _ => {}
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                if v79.1 == v1503.0 {
                                                    if v79.2 == v1503.1 {
                                                        let v1727 = C::subsume(ctx, v1503.1);
                                                        // Rule at src/opts/selects.isle line 116.
                                                        returns.extend(Some(v1727));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v79.2 == v1503.0 {
                                                    if v79.1 == v1503.1 {
                                                        let v1728 = C::subsume(ctx, v1503.0);
                                                        // Rule at src/opts/selects.isle line 118.
                                                        returns.extend(Some(v1728));
                                                        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 v1764,
                                                        args: ref v1765,
                                                    } = &v90.1 {
                                                        match v1764 {
                                                            &Opcode::Isub => {
                                                                if v2.0 == v90.0 {
                                                                    let mut v1516 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v79.2, &mut v1516);
                                                                    let mut v1516 = v1516.into_context_iter();
                                                                    while let Some(v1517) = v1516.next(ctx) {
                                                                        if let &InstructionData::Binary {
                                                                            opcode: ref v1758,
                                                                            args: ref v1759,
                                                                        } = &v1517.1 {
                                                                            if let &Opcode::Isub = v1758 {
                                                                                if v2.0 == v1517.0 {
                                                                                    let v1760 = C::unpack_value_array_2(ctx, v1759);
                                                                                    let v1766 = C::unpack_value_array_2(ctx, v1765);
                                                                                    if v1760.0 == v1766.0 {
                                                                                        let mut v1786 = C::inst_data_value_etor_returns::default();
                                                                                        C::inst_data_value_etor(ctx, v1760.1, &mut v1786);
                                                                                        let mut v1786 = v1786.into_context_iter();
                                                                                        while let Some(v1787) = v1786.next(ctx) {
                                                                                            if let &InstructionData::UnaryImm {
                                                                                                opcode: ref v1790,
                                                                                                imm: v1791,
                                                                                            } = &v1787.1 {
                                                                                                if let &Opcode::Iconst = v1790 {
                                                                                                    if v2.0 == v1787.0 {
                                                                                                        let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                                                        if v1503.0 == v1766.1 {
                                                                                                            let mut v1680 = C::inst_data_value_etor_returns::default();
                                                                                                            C::inst_data_value_etor(ctx, v1503.1, &mut v1680);
                                                                                                            let mut v1680 = v1680.into_context_iter();
                                                                                                            while let Some(v1681) = v1680.next(ctx) {
                                                                                                                if let &InstructionData::UnaryImm {
                                                                                                                    opcode: ref v1684,
                                                                                                                    imm: v1685,
                                                                                                                } = &v1681.1 {
                                                                                                                    if let &Opcode::Iconst = v1684 {
                                                                                                                        if v2.0 == v1681.0 {
                                                                                                                            let v1686 = C::u64_from_imm64(ctx, v1685);
                                                                                                                            let v1792 = C::u64_from_imm64(ctx, v1791);
                                                                                                                            if v1686 == v1792 {
                                                                                                                                let v1785 = constructor_isub(ctx, v2.0, v1766.0, v1503.0);
                                                                                                                                // Rule at src/opts/selects.isle line 186.
                                                                                                                                returns.extend(Some(v1785));
                                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                        if v1503.1 == v1766.1 {
                                                                                                            let mut v1793 = C::inst_data_value_etor_returns::default();
                                                                                                            C::inst_data_value_etor(ctx, v1503.0, &mut v1793);
                                                                                                            let mut v1793 = v1793.into_context_iter();
                                                                                                            while let Some(v1794) = v1793.next(ctx) {
                                                                                                                if let &InstructionData::UnaryImm {
                                                                                                                    opcode: ref v1797,
                                                                                                                    imm: v1798,
                                                                                                                } = &v1794.1 {
                                                                                                                    if let &Opcode::Iconst = v1797 {
                                                                                                                        if v2.0 == v1794.0 {
                                                                                                                            let v1792 = C::u64_from_imm64(ctx, v1791);
                                                                                                                            let v1799 = C::u64_from_imm64(ctx, v1798);
                                                                                                                            if v1792 == v1799 {
                                                                                                                                let v1800 = constructor_isub(ctx, v2.0, v1766.0, v1503.1);
                                                                                                                                // Rule at src/opts/selects.isle line 188.
                                                                                                                                returns.extend(Some(v1800));
                                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Band => {
                                                                if v2.0 == v90.0 {
                                                                    let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                    if v79.2 == v1503.0 {
                                                                        let v1766 = C::unpack_value_array_2(ctx, v1765);
                                                                        if v79.2 == v1766.0 {
                                                                            if v1503.1 == v1766.1 {
                                                                                let v1771 = constructor_band(ctx, v2.0, v1503.1, v1503.0);
                                                                                // Rule at src/opts/selects.isle line 146.
                                                                                returns.extend(Some(v1771));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                        if v79.2 == v1766.1 {
                                                                            if v1503.1 == v1766.0 {
                                                                                let v1771 = constructor_band(ctx, v2.0, v1503.1, v1503.0);
                                                                                // Rule at src/opts/selects.isle line 144.
                                                                                returns.extend(Some(v1771));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                    if v79.2 == v1503.1 {
                                                                        let v1766 = C::unpack_value_array_2(ctx, v1765);
                                                                        if v79.2 == v1766.0 {
                                                                            if v1503.0 == v1766.1 {
                                                                                let v1770 = constructor_band(ctx, v2.0, v1503.0, v1503.1);
                                                                                // Rule at src/opts/selects.isle line 142.
                                                                                returns.extend(Some(v1770));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                        if v1503.0 == v1766.0 {
                                                                            if v79.2 == v1766.1 {
                                                                                let v1770 = constructor_band(ctx, v2.0, v1503.0, v1503.1);
                                                                                // Rule at src/opts/selects.isle line 140.
                                                                                returns.extend(Some(v1770));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Bor => {
                                                                if v2.0 == v90.0 {
                                                                    let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                    if v79.2 == v1503.0 {
                                                                        let v1766 = C::unpack_value_array_2(ctx, v1765);
                                                                        if v79.2 == v1766.0 {
                                                                            if v1503.1 == v1766.1 {
                                                                                let v1763 = constructor_bor(ctx, v2.0, v1503.0, v1503.1);
                                                                                // Rule at src/opts/selects.isle line 130.
                                                                                returns.extend(Some(v1763));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                        if v79.2 == v1766.1 {
                                                                            if v1503.1 == v1766.0 {
                                                                                let v1763 = constructor_bor(ctx, v2.0, v1503.0, v1503.1);
                                                                                // Rule at src/opts/selects.isle line 132.
                                                                                returns.extend(Some(v1763));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                    if v79.2 == v1503.1 {
                                                                        let v1766 = C::unpack_value_array_2(ctx, v1765);
                                                                        if v79.2 == v1766.0 {
                                                                            if v1503.0 == v1766.1 {
                                                                                let v1769 = constructor_bor(ctx, v2.0, v1503.1, v1503.0);
                                                                                // Rule at src/opts/selects.isle line 134.
                                                                                returns.extend(Some(v1769));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                        if v1503.0 == v1766.0 {
                                                                            if v79.2 == v1766.1 {
                                                                                let v1769 = constructor_bor(ctx, v2.0, v1503.1, v1503.0);
                                                                                // Rule at src/opts/selects.isle line 136.
                                                                                returns.extend(Some(v1769));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                    }
                                                }
                                                let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                if v79.1 == v1503.0 {
                                                    if v79.2 == v1503.1 {
                                                        let v1728 = C::subsume(ctx, v1503.0);
                                                        // Rule at src/opts/selects.isle line 119.
                                                        returns.extend(Some(v1728));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v79.1 == v1503.1 {
                                                    if v79.2 == v1503.0 {
                                                        let v1727 = C::subsume(ctx, v1503.1);
                                                        // Rule at src/opts/selects.isle line 117.
                                                        returns.extend(Some(v1727));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::SignedGreaterThan => {
                                                let mut v1516 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v79.2, &mut v1516);
                                                let mut v1516 = v1516.into_context_iter();
                                                while let Some(v1517) = v1516.next(ctx) {
                                                    match &v1517.1 {
                                                        &InstructionData::IntCompare {
                                                            opcode: ref v1520,
                                                            args: ref v1521,
                                                            cond: ref v1522,
                                                        } => {
                                                            if let &Opcode::Icmp = v1520 {
                                                                match v1522 {
                                                                    &IntCC::SignedGreaterThan => {
                                                                        if v2.0 == v1517.0 {
                                                                            let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                            let v1523 = C::unpack_value_array_2(ctx, v1521);
                                                                            if v1503.0 == v1523.1 {
                                                                                if v1503.1 == v1523.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 v1632,
                                                                                            imm: v1633,
                                                                                        } = &v90.1 {
                                                                                            if let &Opcode::Iconst = v1632 {
                                                                                                let v1634 = C::u64_from_imm64(ctx, v1633);
                                                                                                if v1634 == 0x1_u64 {
                                                                                                    if v2.0 == v90.0 {
                                                                                                        let v1775 = constructor_ne(ctx, v2.0, v1503.1, v1503.0);
                                                                                                        // Rule at src/opts/selects.isle line 164.
                                                                                                        returns.extend(Some(v1775));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedLessThan => {
                                                                        if v2.0 == v1517.0 {
                                                                            let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                            let v1523 = C::unpack_value_array_2(ctx, v1521);
                                                                            if v1503.0 == v1523.0 {
                                                                                if v1503.1 == v1523.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 v1632,
                                                                                            imm: v1633,
                                                                                        } = &v90.1 {
                                                                                            if let &Opcode::Iconst = v1632 {
                                                                                                let v1634 = C::u64_from_imm64(ctx, v1633);
                                                                                                if v1634 == 0x1_u64 {
                                                                                                    if v2.0 == v90.0 {
                                                                                                        let v1775 = constructor_ne(ctx, v2.0, v1503.1, v1503.0);
                                                                                                        // Rule at src/opts/selects.isle line 168.
                                                                                                        returns.extend(Some(v1775));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v1674,
                                                            arg: v1675,
                                                        } => {
                                                            match v1674 {
                                                                &Opcode::Ineg => {
                                                                    if v84.0 == v1517.0 {
                                                                        let mut v1644 = C::inst_data_value_tupled_etor_returns::default();
                                                                        C::inst_data_value_tupled_etor(ctx, v79.1, &mut v1644);
                                                                        let mut v1644 = v1644.into_context_iter();
                                                                        while let Some(v1645) = v1644.next(ctx) {
                                                                            let v1646 = C::iconst_sextend_etor(ctx, v1645);
                                                                            if let Some(v1647) = v1646 {
                                                                                if v1647.1 == 1_i64 {
                                                                                    if v2.0 == v1647.0 {
                                                                                        let mut v1968 = C::inst_data_value_etor_returns::default();
                                                                                        C::inst_data_value_etor(ctx, v1675, &mut v1968);
                                                                                        let mut v1968 = v1968.into_context_iter();
                                                                                        while let Some(v1969) = v1968.next(ctx) {
                                                                                            if let &InstructionData::IntCompare {
                                                                                                opcode: ref v1972,
                                                                                                args: ref v1973,
                                                                                                cond: ref v1974,
                                                                                            } = &v1969.1 {
                                                                                                if let &Opcode::Icmp = v1972 {
                                                                                                    match v1974 {
                                                                                                        &IntCC::NotEqual => {
                                                                                                            if v84.0 == v1969.0 {
                                                                                                                let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                                                                let v1975 = C::unpack_value_array_2(ctx, v1973);
                                                                                                                if v1503.0 == v1975.0 {
                                                                                                                    if v1503.1 == v1975.1 {
                                                                                                                        let v1978 = constructor_spaceship_s(ctx, v84.0, v1503.0, v1503.1);
                                                                                                                        let v1979 = constructor_sextend_maybe(ctx, v2.0, v1978);
                                                                                                                        // Rule at src/opts/spaceship.isle line 129.
                                                                                                                        returns.extend(Some(v1979));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                        &IntCC::SignedLessThan => {
                                                                                                            if v84.0 == v1969.0 {
                                                                                                                let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                                                                let v1975 = C::unpack_value_array_2(ctx, v1973);
                                                                                                                if v1503.0 == v1975.0 {
                                                                                                                    if v1503.1 == v1975.1 {
                                                                                                                        let v1978 = constructor_spaceship_s(ctx, v84.0, v1503.0, v1503.1);
                                                                                                                        let v1979 = constructor_sextend_maybe(ctx, v2.0, v1978);
                                                                                                                        // Rule at src/opts/spaceship.isle line 119.
                                                                                                                        returns.extend(Some(v1979));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                        _ => {}
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    if v2.0 == v1517.0 {
                                                                        let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                        if v79.1 == v1503.0 {
                                                                            if v79.1 == v1675 {
                                                                                let mut v1680 = C::inst_data_value_etor_returns::default();
                                                                                C::inst_data_value_etor(ctx, v1503.1, &mut v1680);
                                                                                let mut v1680 = v1680.into_context_iter();
                                                                                while let Some(v1681) = v1680.next(ctx) {
                                                                                    if let &InstructionData::UnaryImm {
                                                                                        opcode: ref v1684,
                                                                                        imm: v1685,
                                                                                    } = &v1681.1 {
                                                                                        if let &Opcode::Iconst = v1684 {
                                                                                            let v1686 = C::u64_from_imm64(ctx, v1685);
                                                                                            if v1686 == 0x0_u64 {
                                                                                                if v2.0 == v1681.0 {
                                                                                                    let v1687 = constructor_iabs(ctx, v2.0, v1503.0);
                                                                                                    let v1688 = C::subsume(ctx, v1687);
                                                                                                    // Rule at src/opts/selects.isle line 89.
                                                                                                    returns.extend(Some(v1688));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Bmask => {
                                                                    if v2.0 == v1517.0 {
                                                                        let mut v1644 = C::inst_data_value_tupled_etor_returns::default();
                                                                        C::inst_data_value_tupled_etor(ctx, v79.1, &mut v1644);
                                                                        let mut v1644 = v1644.into_context_iter();
                                                                        while let Some(v1645) = v1644.next(ctx) {
                                                                            let v1646 = C::iconst_sextend_etor(ctx, v1645);
                                                                            if let Some(v1647) = v1646 {
                                                                                if v1647.1 == 1_i64 {
                                                                                    if v2.0 == v1647.0 {
                                                                                        let mut v1968 = C::inst_data_value_etor_returns::default();
                                                                                        C::inst_data_value_etor(ctx, v1675, &mut v1968);
                                                                                        let mut v1968 = v1968.into_context_iter();
                                                                                        while let Some(v1969) = v1968.next(ctx) {
                                                                                            if let &InstructionData::IntCompare {
                                                                                                opcode: ref v1972,
                                                                                                args: ref v1973,
                                                                                                cond: ref v1974,
                                                                                            } = &v1969.1 {
                                                                                                if let &Opcode::Icmp = v1972 {
                                                                                                    match v1974 {
                                                                                                        &IntCC::NotEqual => {
                                                                                                            if v84.0 == v1969.0 {
                                                                                                                let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                                                                let v1975 = C::unpack_value_array_2(ctx, v1973);
                                                                                                                if v1503.0 == v1975.0 {
                                                                                                                    if v1503.1 == v1975.1 {
                                                                                                                        let v1978 = constructor_spaceship_s(ctx, v84.0, v1503.0, v1503.1);
                                                                                                                        let v1979 = constructor_sextend_maybe(ctx, v2.0, v1978);
                                                                                                                        // Rule at src/opts/spaceship.isle line 133.
                                                                                                                        returns.extend(Some(v1979));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                        &IntCC::SignedLessThan => {
                                                                                                            if v84.0 == v1969.0 {
                                                                                                                let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                                                                let v1975 = C::unpack_value_array_2(ctx, v1973);
                                                                                                                if v1503.0 == v1975.0 {
                                                                                                                    if v1503.1 == v1975.1 {
                                                                                                                        let v1978 = constructor_spaceship_s(ctx, v84.0, v1503.0, v1503.1);
                                                                                                                        let v1979 = constructor_sextend_maybe(ctx, v2.0, v1978);
                                                                                                                        // Rule at src/opts/spaceship.isle line 123.
                                                                                                                        returns.extend(Some(v1979));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                        _ => {}
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                if v79.1 == v1503.0 {
                                                    if v79.2 == v1503.1 {
                                                        let v1657 = constructor_smax(ctx, v2.0, v1503.0, v1503.1);
                                                        // Rule at src/opts/selects.isle line 25.
                                                        returns.extend(Some(v1657));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v79.2 == v1503.0 {
                                                    if v79.1 == v1503.1 {
                                                        let v1659 = constructor_smin(ctx, v2.0, v1503.0, v1503.1);
                                                        // Rule at src/opts/selects.isle line 39.
                                                        returns.extend(Some(v1659));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::SignedGreaterThanOrEqual => {
                                                let mut v1516 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v79.2, &mut v1516);
                                                let mut v1516 = v1516.into_context_iter();
                                                while let Some(v1517) = v1516.next(ctx) {
                                                    match &v1517.1 {
                                                        &InstructionData::Unary {
                                                            opcode: ref v1674,
                                                            arg: v1675,
                                                        } => {
                                                            if let &Opcode::Ineg = v1674 {
                                                                if v2.0 == v1517.0 {
                                                                    let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                    if v79.1 == v1503.0 {
                                                                        if v79.1 == v1675 {
                                                                            let mut v1680 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v1503.1, &mut v1680);
                                                                            let mut v1680 = v1680.into_context_iter();
                                                                            while let Some(v1681) = v1680.next(ctx) {
                                                                                if let &InstructionData::UnaryImm {
                                                                                    opcode: ref v1684,
                                                                                    imm: v1685,
                                                                                } = &v1681.1 {
                                                                                    if let &Opcode::Iconst = v1684 {
                                                                                        let v1686 = C::u64_from_imm64(ctx, v1685);
                                                                                        if v1686 == 0x0_u64 {
                                                                                            if v2.0 == v1681.0 {
                                                                                                let v1687 = constructor_iabs(ctx, v2.0, v1503.0);
                                                                                                let v1688 = C::subsume(ctx, v1687);
                                                                                                // Rule at src/opts/selects.isle line 90.
                                                                                                returns.extend(Some(v1688));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::UnaryImm {
                                                            opcode: ref v1635,
                                                            imm: v1636,
                                                        } => {
                                                            if let &Opcode::Iconst = v1635 {
                                                                let v1637 = C::u64_from_imm64(ctx, v1636);
                                                                if v1637 == 0x1_u64 {
                                                                    if v2.0 == v1517.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 v1508,
                                                                                args: ref v1509,
                                                                                cond: ref v1510,
                                                                            } = &v90.1 {
                                                                                if let &Opcode::Icmp = v1508 {
                                                                                    match v1510 {
                                                                                        &IntCC::SignedGreaterThan => {
                                                                                            if v2.0 == v90.0 {
                                                                                                let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                                                let v1511 = C::unpack_value_array_2(ctx, v1509);
                                                                                                if v1503.0 == v1511.0 {
                                                                                                    if v1503.1 == v1511.1 {
                                                                                                        let v1774 = constructor_ne(ctx, v2.0, v1503.0, v1503.1);
                                                                                                        // Rule at src/opts/selects.isle line 163.
                                                                                                        returns.extend(Some(v1774));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                        &IntCC::SignedLessThan => {
                                                                                            if v2.0 == v90.0 {
                                                                                                let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                                                let v1511 = C::unpack_value_array_2(ctx, v1509);
                                                                                                if v1503.0 == v1511.1 {
                                                                                                    if v1503.1 == v1511.0 {
                                                                                                        let v1774 = constructor_ne(ctx, v2.0, v1503.0, v1503.1);
                                                                                                        // Rule at src/opts/selects.isle line 167.
                                                                                                        returns.extend(Some(v1774));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                        _ => {}
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                if v79.1 == v1503.0 {
                                                    if v79.2 == v1503.1 {
                                                        let v1657 = constructor_smax(ctx, v2.0, v1503.0, v1503.1);
                                                        // Rule at src/opts/selects.isle line 26.
                                                        returns.extend(Some(v1657));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v79.2 == v1503.0 {
                                                    if v79.1 == v1503.1 {
                                                        let v1659 = constructor_smin(ctx, v2.0, v1503.0, v1503.1);
                                                        // Rule at src/opts/selects.isle line 40.
                                                        returns.extend(Some(v1659));
                                                        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 v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                        if v79.2 == v1503.0 {
                                                                            let mut v1680 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v1503.1, &mut v1680);
                                                                            let mut v1680 = v1680.into_context_iter();
                                                                            while let Some(v1681) = v1680.next(ctx) {
                                                                                if let &InstructionData::UnaryImm {
                                                                                    opcode: ref v1684,
                                                                                    imm: v1685,
                                                                                } = &v1681.1 {
                                                                                    if let &Opcode::Iconst = v1684 {
                                                                                        let v1686 = C::u64_from_imm64(ctx, v1685);
                                                                                        if v1686 == 0x0_u64 {
                                                                                            if v2.0 == v1681.0 {
                                                                                                let v1687 = constructor_iabs(ctx, v2.0, v1503.0);
                                                                                                let v1688 = C::subsume(ctx, v1687);
                                                                                                // Rule at src/opts/selects.isle line 92.
                                                                                                returns.extend(Some(v1688));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::UnaryImm {
                                                            opcode: ref v1632,
                                                            imm: v1633,
                                                        } => {
                                                            if let &Opcode::Iconst = v1632 {
                                                                let v1634 = C::u64_from_imm64(ctx, v1633);
                                                                if v1634 == 0x1_u64 {
                                                                    if v2.0 == v90.0 {
                                                                        let mut v1516 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v79.2, &mut v1516);
                                                                        let mut v1516 = v1516.into_context_iter();
                                                                        while let Some(v1517) = v1516.next(ctx) {
                                                                            if let &InstructionData::IntCompare {
                                                                                opcode: ref v1520,
                                                                                args: ref v1521,
                                                                                cond: ref v1522,
                                                                            } = &v1517.1 {
                                                                                if let &Opcode::Icmp = v1520 {
                                                                                    match v1522 {
                                                                                        &IntCC::SignedGreaterThan => {
                                                                                            if v2.0 == v1517.0 {
                                                                                                let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                                                let v1523 = C::unpack_value_array_2(ctx, v1521);
                                                                                                if v1503.0 == v1523.0 {
                                                                                                    if v1503.1 == v1523.1 {
                                                                                                        let v1774 = constructor_ne(ctx, v2.0, v1503.0, v1503.1);
                                                                                                        // Rule at src/opts/selects.isle line 162.
                                                                                                        returns.extend(Some(v1774));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                        &IntCC::SignedLessThan => {
                                                                                            if v2.0 == v1517.0 {
                                                                                                let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                                                let v1523 = C::unpack_value_array_2(ctx, v1521);
                                                                                                if v1503.0 == v1523.1 {
                                                                                                    if v1503.1 == v1523.0 {
                                                                                                        let v1774 = constructor_ne(ctx, v2.0, v1503.0, v1503.1);
                                                                                                        // Rule at src/opts/selects.isle line 166.
                                                                                                        returns.extend(Some(v1774));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                        _ => {}
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let mut v1644 = C::inst_data_value_tupled_etor_returns::default();
                                                C::inst_data_value_tupled_etor(ctx, v79.1, &mut v1644);
                                                let mut v1644 = v1644.into_context_iter();
                                                while let Some(v1645) = v1644.next(ctx) {
                                                    let v1646 = C::iconst_sextend_etor(ctx, v1645);
                                                    if let Some(v1647) = v1646 {
                                                        if v1647.1 == -1_i64 {
                                                            if v2.0 == v1647.0 {
                                                                let mut v1930 = C::uextend_maybe_etor_returns::default();
                                                                C::uextend_maybe_etor(ctx, v79.2, &mut v1930);
                                                                let mut v1930 = v1930.into_context_iter();
                                                                while let Some(v1931) = v1930.next(ctx) {
                                                                    if v2.0 == v1931.0 {
                                                                        let mut v1934 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v1931.1, &mut v1934);
                                                                        let mut v1934 = v1934.into_context_iter();
                                                                        while let Some(v1935) = v1934.next(ctx) {
                                                                            if let &InstructionData::IntCompare {
                                                                                opcode: ref v1938,
                                                                                args: ref v1939,
                                                                                cond: ref v1940,
                                                                            } = &v1935.1 {
                                                                                if let &Opcode::Icmp = v1938 {
                                                                                    match v1940 {
                                                                                        &IntCC::NotEqual => {
                                                                                            if v84.0 == v1935.0 {
                                                                                                let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                                                let v1941 = C::unpack_value_array_2(ctx, v1939);
                                                                                                if v1503.0 == v1941.0 {
                                                                                                    if v1503.1 == v1941.1 {
                                                                                                        let v1978 = constructor_spaceship_s(ctx, v84.0, v1503.0, v1503.1);
                                                                                                        let v1979 = constructor_sextend_maybe(ctx, v2.0, v1978);
                                                                                                        // Rule at src/opts/spaceship.isle line 77.
                                                                                                        returns.extend(Some(v1979));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                        &IntCC::SignedGreaterThan => {
                                                                                            if v84.0 == v1935.0 {
                                                                                                let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                                                let v1941 = C::unpack_value_array_2(ctx, v1939);
                                                                                                if v1503.0 == v1941.0 {
                                                                                                    if v1503.1 == v1941.1 {
                                                                                                        let v1978 = constructor_spaceship_s(ctx, v84.0, v1503.0, v1503.1);
                                                                                                        let v1979 = constructor_sextend_maybe(ctx, v2.0, v1978);
                                                                                                        // Rule at src/opts/spaceship.isle line 83.
                                                                                                        returns.extend(Some(v1979));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                        _ => {}
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                if v79.1 == v1503.0 {
                                                    if v79.2 == v1503.1 {
                                                        let v1659 = constructor_smin(ctx, v2.0, v1503.0, v1503.1);
                                                        // Rule at src/opts/selects.isle line 29.
                                                        returns.extend(Some(v1659));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v79.1 == v1503.1 {
                                                    if v79.2 == v1503.0 {
                                                        let v1657 = constructor_smax(ctx, v2.0, v1503.0, v1503.1);
                                                        // Rule at src/opts/selects.isle line 35.
                                                        returns.extend(Some(v1657));
                                                        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 v1508,
                                                            args: ref v1509,
                                                            cond: ref v1510,
                                                        } => {
                                                            if let &Opcode::Icmp = v1508 {
                                                                match v1510 {
                                                                    &IntCC::SignedGreaterThan => {
                                                                        if v2.0 == v90.0 {
                                                                            let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                            let v1511 = C::unpack_value_array_2(ctx, v1509);
                                                                            if v1503.0 == v1511.1 {
                                                                                if v1503.1 == v1511.0 {
                                                                                    let mut v1516 = C::inst_data_value_etor_returns::default();
                                                                                    C::inst_data_value_etor(ctx, v79.2, &mut v1516);
                                                                                    let mut v1516 = v1516.into_context_iter();
                                                                                    while let Some(v1517) = v1516.next(ctx) {
                                                                                        if let &InstructionData::UnaryImm {
                                                                                            opcode: ref v1635,
                                                                                            imm: v1636,
                                                                                        } = &v1517.1 {
                                                                                            if let &Opcode::Iconst = v1635 {
                                                                                                let v1637 = C::u64_from_imm64(ctx, v1636);
                                                                                                if v1637 == 0x1_u64 {
                                                                                                    if v2.0 == v1517.0 {
                                                                                                        let v1775 = constructor_ne(ctx, v2.0, v1503.1, v1503.0);
                                                                                                        // Rule at src/opts/selects.isle line 165.
                                                                                                        returns.extend(Some(v1775));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedLessThan => {
                                                                        if v2.0 == v90.0 {
                                                                            let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                            let v1511 = C::unpack_value_array_2(ctx, v1509);
                                                                            if v1503.0 == v1511.0 {
                                                                                if v1503.1 == v1511.1 {
                                                                                    let mut v1516 = C::inst_data_value_etor_returns::default();
                                                                                    C::inst_data_value_etor(ctx, v79.2, &mut v1516);
                                                                                    let mut v1516 = v1516.into_context_iter();
                                                                                    while let Some(v1517) = v1516.next(ctx) {
                                                                                        if let &InstructionData::UnaryImm {
                                                                                            opcode: ref v1635,
                                                                                            imm: v1636,
                                                                                        } = &v1517.1 {
                                                                                            if let &Opcode::Iconst = v1635 {
                                                                                                let v1637 = C::u64_from_imm64(ctx, v1636);
                                                                                                if v1637 == 0x1_u64 {
                                                                                                    if v2.0 == v1517.0 {
                                                                                                        let v1775 = constructor_ne(ctx, v2.0, v1503.1, v1503.0);
                                                                                                        // Rule at src/opts/selects.isle line 169.
                                                                                                        returns.extend(Some(v1775));
                                                                                                        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 v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                        if v79.2 == v1503.0 {
                                                                            let mut v1680 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v1503.1, &mut v1680);
                                                                            let mut v1680 = v1680.into_context_iter();
                                                                            while let Some(v1681) = v1680.next(ctx) {
                                                                                if let &InstructionData::UnaryImm {
                                                                                    opcode: ref v1684,
                                                                                    imm: v1685,
                                                                                } = &v1681.1 {
                                                                                    if let &Opcode::Iconst = v1684 {
                                                                                        let v1686 = C::u64_from_imm64(ctx, v1685);
                                                                                        if v1686 == 0x0_u64 {
                                                                                            if v2.0 == v1681.0 {
                                                                                                let v1687 = constructor_iabs(ctx, v2.0, v1503.0);
                                                                                                let v1688 = C::subsume(ctx, v1687);
                                                                                                // Rule at src/opts/selects.isle line 91.
                                                                                                returns.extend(Some(v1688));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                if v79.1 == v1503.0 {
                                                    if v79.2 == v1503.1 {
                                                        let v1659 = constructor_smin(ctx, v2.0, v1503.0, v1503.1);
                                                        // Rule at src/opts/selects.isle line 30.
                                                        returns.extend(Some(v1659));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v79.1 == v1503.1 {
                                                    if v79.2 == v1503.0 {
                                                        let v1657 = constructor_smax(ctx, v2.0, v1503.0, v1503.1);
                                                        // Rule at src/opts/selects.isle line 36.
                                                        returns.extend(Some(v1657));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::UnsignedGreaterThan => {
                                                let mut v1516 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v79.2, &mut v1516);
                                                let mut v1516 = v1516.into_context_iter();
                                                while let Some(v1517) = v1516.next(ctx) {
                                                    match &v1517.1 {
                                                        &InstructionData::IntCompare {
                                                            opcode: ref v1520,
                                                            args: ref v1521,
                                                            cond: ref v1522,
                                                        } => {
                                                            if let &Opcode::Icmp = v1520 {
                                                                match v1522 {
                                                                    &IntCC::Equal => {
                                                                        if v2.0 == v1517.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 v1632,
                                                                                    imm: v1633,
                                                                                } = &v90.1 {
                                                                                    if let &Opcode::Iconst = v1632 {
                                                                                        let v1634 = C::u64_from_imm64(ctx, v1633);
                                                                                        if v1634 == 0x1_u64 {
                                                                                            if v2.0 == v90.0 {
                                                                                                let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                                                let v1523 = C::unpack_value_array_2(ctx, v1521);
                                                                                                if v1503.0 == v1523.0 {
                                                                                                    if v1503.1 == v1523.1 {
                                                                                                        let v1773 = constructor_ule(ctx, v2.0, v1503.1, v1503.0);
                                                                                                        // Rule at src/opts/selects.isle line 157.
                                                                                                        returns.extend(Some(v1773));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                                if v1503.0 == v1523.1 {
                                                                                                    if v1503.1 == v1523.0 {
                                                                                                        let v1773 = constructor_ule(ctx, v2.0, v1503.1, v1503.0);
                                                                                                        // Rule at src/opts/selects.isle line 153.
                                                                                                        returns.extend(Some(v1773));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedGreaterThan => {
                                                                        if v2.0 == v1517.0 {
                                                                            let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                            let v1523 = C::unpack_value_array_2(ctx, v1521);
                                                                            if v1503.0 == v1523.1 {
                                                                                if v1503.1 == v1523.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 v1632,
                                                                                            imm: v1633,
                                                                                        } = &v90.1 {
                                                                                            if let &Opcode::Iconst = v1632 {
                                                                                                let v1634 = C::u64_from_imm64(ctx, v1633);
                                                                                                if v1634 == 0x1_u64 {
                                                                                                    if v2.0 == v90.0 {
                                                                                                        let v1775 = constructor_ne(ctx, v2.0, v1503.1, v1503.0);
                                                                                                        // Rule at src/opts/selects.isle line 172.
                                                                                                        returns.extend(Some(v1775));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        if v2.0 == v1517.0 {
                                                                            let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                            let v1523 = C::unpack_value_array_2(ctx, v1521);
                                                                            if v1503.0 == v1523.0 {
                                                                                if v1503.1 == v1523.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 v1632,
                                                                                            imm: v1633,
                                                                                        } = &v90.1 {
                                                                                            if let &Opcode::Iconst = v1632 {
                                                                                                let v1634 = C::u64_from_imm64(ctx, v1633);
                                                                                                if v1634 == 0x1_u64 {
                                                                                                    if v2.0 == v90.0 {
                                                                                                        let v1775 = constructor_ne(ctx, v2.0, v1503.1, v1503.0);
                                                                                                        // Rule at src/opts/selects.isle line 176.
                                                                                                        returns.extend(Some(v1775));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v1674,
                                                            arg: v1675,
                                                        } => {
                                                            match v1674 {
                                                                &Opcode::Ineg => {
                                                                    if v84.0 == v1517.0 {
                                                                        let mut v1644 = C::inst_data_value_tupled_etor_returns::default();
                                                                        C::inst_data_value_tupled_etor(ctx, v79.1, &mut v1644);
                                                                        let mut v1644 = v1644.into_context_iter();
                                                                        while let Some(v1645) = v1644.next(ctx) {
                                                                            let v1646 = C::iconst_sextend_etor(ctx, v1645);
                                                                            if let Some(v1647) = v1646 {
                                                                                if v1647.1 == 1_i64 {
                                                                                    if v2.0 == v1647.0 {
                                                                                        let mut v1968 = C::inst_data_value_etor_returns::default();
                                                                                        C::inst_data_value_etor(ctx, v1675, &mut v1968);
                                                                                        let mut v1968 = v1968.into_context_iter();
                                                                                        while let Some(v1969) = v1968.next(ctx) {
                                                                                            if let &InstructionData::IntCompare {
                                                                                                opcode: ref v1972,
                                                                                                args: ref v1973,
                                                                                                cond: ref v1974,
                                                                                            } = &v1969.1 {
                                                                                                if let &Opcode::Icmp = v1972 {
                                                                                                    match v1974 {
                                                                                                        &IntCC::NotEqual => {
                                                                                                            if v84.0 == v1969.0 {
                                                                                                                let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                                                                let v1975 = C::unpack_value_array_2(ctx, v1973);
                                                                                                                if v1503.0 == v1975.0 {
                                                                                                                    if v1503.1 == v1975.1 {
                                                                                                                        let v1944 = constructor_spaceship_u(ctx, v84.0, v1503.0, v1503.1);
                                                                                                                        let v1945 = constructor_sextend_maybe(ctx, v2.0, v1944);
                                                                                                                        // Rule at src/opts/spaceship.isle line 64.
                                                                                                                        returns.extend(Some(v1945));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                        &IntCC::UnsignedLessThan => {
                                                                                                            if v84.0 == v1969.0 {
                                                                                                                let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                                                                let v1975 = C::unpack_value_array_2(ctx, v1973);
                                                                                                                if v1503.0 == v1975.0 {
                                                                                                                    if v1503.1 == v1975.1 {
                                                                                                                        let v1944 = constructor_spaceship_u(ctx, v84.0, v1503.0, v1503.1);
                                                                                                                        let v1945 = constructor_sextend_maybe(ctx, v2.0, v1944);
                                                                                                                        // Rule at src/opts/spaceship.isle line 54.
                                                                                                                        returns.extend(Some(v1945));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                        _ => {}
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &Opcode::Bmask => {
                                                                    if v2.0 == v1517.0 {
                                                                        let mut v1644 = C::inst_data_value_tupled_etor_returns::default();
                                                                        C::inst_data_value_tupled_etor(ctx, v79.1, &mut v1644);
                                                                        let mut v1644 = v1644.into_context_iter();
                                                                        while let Some(v1645) = v1644.next(ctx) {
                                                                            let v1646 = C::iconst_sextend_etor(ctx, v1645);
                                                                            if let Some(v1647) = v1646 {
                                                                                if v1647.1 == 1_i64 {
                                                                                    if v2.0 == v1647.0 {
                                                                                        let mut v1968 = C::inst_data_value_etor_returns::default();
                                                                                        C::inst_data_value_etor(ctx, v1675, &mut v1968);
                                                                                        let mut v1968 = v1968.into_context_iter();
                                                                                        while let Some(v1969) = v1968.next(ctx) {
                                                                                            if let &InstructionData::IntCompare {
                                                                                                opcode: ref v1972,
                                                                                                args: ref v1973,
                                                                                                cond: ref v1974,
                                                                                            } = &v1969.1 {
                                                                                                if let &Opcode::Icmp = v1972 {
                                                                                                    match v1974 {
                                                                                                        &IntCC::NotEqual => {
                                                                                                            if v84.0 == v1969.0 {
                                                                                                                let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                                                                let v1975 = C::unpack_value_array_2(ctx, v1973);
                                                                                                                if v1503.0 == v1975.0 {
                                                                                                                    if v1503.1 == v1975.1 {
                                                                                                                        let v1944 = constructor_spaceship_u(ctx, v84.0, v1503.0, v1503.1);
                                                                                                                        let v1945 = constructor_sextend_maybe(ctx, v2.0, v1944);
                                                                                                                        // Rule at src/opts/spaceship.isle line 68.
                                                                                                                        returns.extend(Some(v1945));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                        &IntCC::UnsignedLessThan => {
                                                                                                            if v84.0 == v1969.0 {
                                                                                                                let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                                                                let v1975 = C::unpack_value_array_2(ctx, v1973);
                                                                                                                if v1503.0 == v1975.0 {
                                                                                                                    if v1503.1 == v1975.1 {
                                                                                                                        let v1944 = constructor_spaceship_u(ctx, v84.0, v1503.0, v1503.1);
                                                                                                                        let v1945 = constructor_sextend_maybe(ctx, v2.0, v1944);
                                                                                                                        // Rule at src/opts/spaceship.isle line 58.
                                                                                                                        returns.extend(Some(v1945));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                        _ => {}
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                if v79.1 == v1503.0 {
                                                    if v79.2 == v1503.1 {
                                                        let v1658 = constructor_umax(ctx, v2.0, v1503.0, v1503.1);
                                                        // Rule at src/opts/selects.isle line 27.
                                                        returns.extend(Some(v1658));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v79.2 == v1503.0 {
                                                    if v79.1 == v1503.1 {
                                                        let v1660 = constructor_umin(ctx, v2.0, v1503.0, v1503.1);
                                                        // Rule at src/opts/selects.isle line 41.
                                                        returns.extend(Some(v1660));
                                                        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 v1508,
                                                        args: ref v1509,
                                                        cond: ref v1510,
                                                    } = &v90.1 {
                                                        if let &Opcode::Icmp = v1508 {
                                                            match v1510 {
                                                                &IntCC::Equal => {
                                                                    if v2.0 == v90.0 {
                                                                        let mut v1516 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v79.2, &mut v1516);
                                                                        let mut v1516 = v1516.into_context_iter();
                                                                        while let Some(v1517) = v1516.next(ctx) {
                                                                            if let &InstructionData::UnaryImm {
                                                                                opcode: ref v1635,
                                                                                imm: v1636,
                                                                            } = &v1517.1 {
                                                                                if let &Opcode::Iconst = v1635 {
                                                                                    let v1637 = C::u64_from_imm64(ctx, v1636);
                                                                                    if v1637 == 0x1_u64 {
                                                                                        if v2.0 == v1517.0 {
                                                                                            let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                                            let v1511 = C::unpack_value_array_2(ctx, v1509);
                                                                                            if v1503.0 == v1511.0 {
                                                                                                if v1503.1 == v1511.1 {
                                                                                                    let v1772 = constructor_ule(ctx, v2.0, v1503.0, v1503.1);
                                                                                                    // Rule at src/opts/selects.isle line 152.
                                                                                                    returns.extend(Some(v1772));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                            if v1503.0 == v1511.1 {
                                                                                                if v1503.1 == v1511.0 {
                                                                                                    let v1772 = constructor_ule(ctx, v2.0, v1503.0, v1503.1);
                                                                                                    // Rule at src/opts/selects.isle line 156.
                                                                                                    returns.extend(Some(v1772));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &IntCC::UnsignedGreaterThan => {
                                                                    if v2.0 == v90.0 {
                                                                        let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                        let v1511 = C::unpack_value_array_2(ctx, v1509);
                                                                        if v1503.0 == v1511.0 {
                                                                            if v1503.1 == v1511.1 {
                                                                                let mut v1516 = C::inst_data_value_etor_returns::default();
                                                                                C::inst_data_value_etor(ctx, v79.2, &mut v1516);
                                                                                let mut v1516 = v1516.into_context_iter();
                                                                                while let Some(v1517) = v1516.next(ctx) {
                                                                                    if let &InstructionData::UnaryImm {
                                                                                        opcode: ref v1635,
                                                                                        imm: v1636,
                                                                                    } = &v1517.1 {
                                                                                        if let &Opcode::Iconst = v1635 {
                                                                                            let v1637 = C::u64_from_imm64(ctx, v1636);
                                                                                            if v1637 == 0x1_u64 {
                                                                                                if v2.0 == v1517.0 {
                                                                                                    let v1774 = constructor_ne(ctx, v2.0, v1503.0, v1503.1);
                                                                                                    // Rule at src/opts/selects.isle line 171.
                                                                                                    returns.extend(Some(v1774));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &IntCC::UnsignedLessThan => {
                                                                    if v2.0 == v90.0 {
                                                                        let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                        let v1511 = C::unpack_value_array_2(ctx, v1509);
                                                                        if v1503.0 == v1511.1 {
                                                                            if v1503.1 == v1511.0 {
                                                                                let mut v1516 = C::inst_data_value_etor_returns::default();
                                                                                C::inst_data_value_etor(ctx, v79.2, &mut v1516);
                                                                                let mut v1516 = v1516.into_context_iter();
                                                                                while let Some(v1517) = v1516.next(ctx) {
                                                                                    if let &InstructionData::UnaryImm {
                                                                                        opcode: ref v1635,
                                                                                        imm: v1636,
                                                                                    } = &v1517.1 {
                                                                                        if let &Opcode::Iconst = v1635 {
                                                                                            let v1637 = C::u64_from_imm64(ctx, v1636);
                                                                                            if v1637 == 0x1_u64 {
                                                                                                if v2.0 == v1517.0 {
                                                                                                    let v1774 = constructor_ne(ctx, v2.0, v1503.0, v1503.1);
                                                                                                    // Rule at src/opts/selects.isle line 175.
                                                                                                    returns.extend(Some(v1774));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                    }
                                                }
                                                let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                if v79.1 == v1503.0 {
                                                    if v79.2 == v1503.1 {
                                                        let v1658 = constructor_umax(ctx, v2.0, v1503.0, v1503.1);
                                                        // Rule at src/opts/selects.isle line 28.
                                                        returns.extend(Some(v1658));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v79.1 == v1503.1 {
                                                    if v79.2 == v1503.0 {
                                                        let v1660 = constructor_umin(ctx, v2.0, v1503.0, v1503.1);
                                                        // Rule at src/opts/selects.isle line 42.
                                                        returns.extend(Some(v1660));
                                                        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 v1632,
                                                        imm: v1633,
                                                    } = &v90.1 {
                                                        if let &Opcode::Iconst = v1632 {
                                                            let v1634 = C::u64_from_imm64(ctx, v1633);
                                                            if v1634 == 0x1_u64 {
                                                                if v2.0 == v90.0 {
                                                                    let mut v1516 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v79.2, &mut v1516);
                                                                    let mut v1516 = v1516.into_context_iter();
                                                                    while let Some(v1517) = v1516.next(ctx) {
                                                                        if let &InstructionData::IntCompare {
                                                                            opcode: ref v1520,
                                                                            args: ref v1521,
                                                                            cond: ref v1522,
                                                                        } = &v1517.1 {
                                                                            if let &Opcode::Icmp = v1520 {
                                                                                match v1522 {
                                                                                    &IntCC::Equal => {
                                                                                        if v2.0 == v1517.0 {
                                                                                            let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                                            let v1523 = C::unpack_value_array_2(ctx, v1521);
                                                                                            if v1503.0 == v1523.0 {
                                                                                                if v1503.1 == v1523.1 {
                                                                                                    let v1772 = constructor_ule(ctx, v2.0, v1503.0, v1503.1);
                                                                                                    // Rule at src/opts/selects.isle line 151.
                                                                                                    returns.extend(Some(v1772));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                            if v1503.0 == v1523.1 {
                                                                                                if v1503.1 == v1523.0 {
                                                                                                    let v1772 = constructor_ule(ctx, v2.0, v1503.0, v1503.1);
                                                                                                    // Rule at src/opts/selects.isle line 155.
                                                                                                    returns.extend(Some(v1772));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                    &IntCC::UnsignedGreaterThan => {
                                                                                        if v2.0 == v1517.0 {
                                                                                            let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                                            let v1523 = C::unpack_value_array_2(ctx, v1521);
                                                                                            if v1503.0 == v1523.0 {
                                                                                                if v1503.1 == v1523.1 {
                                                                                                    let v1774 = constructor_ne(ctx, v2.0, v1503.0, v1503.1);
                                                                                                    // Rule at src/opts/selects.isle line 170.
                                                                                                    returns.extend(Some(v1774));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                    &IntCC::UnsignedLessThan => {
                                                                                        if v2.0 == v1517.0 {
                                                                                            let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                                            let v1523 = C::unpack_value_array_2(ctx, v1521);
                                                                                            if v1503.0 == v1523.1 {
                                                                                                if v1503.1 == v1523.0 {
                                                                                                    let v1774 = constructor_ne(ctx, v2.0, v1503.0, v1503.1);
                                                                                                    // Rule at src/opts/selects.isle line 174.
                                                                                                    returns.extend(Some(v1774));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                    _ => {}
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                let mut v1644 = C::inst_data_value_tupled_etor_returns::default();
                                                C::inst_data_value_tupled_etor(ctx, v79.1, &mut v1644);
                                                let mut v1644 = v1644.into_context_iter();
                                                while let Some(v1645) = v1644.next(ctx) {
                                                    let v1646 = C::iconst_sextend_etor(ctx, v1645);
                                                    if let Some(v1647) = v1646 {
                                                        if v1647.1 == -1_i64 {
                                                            if v2.0 == v1647.0 {
                                                                let mut v1930 = C::uextend_maybe_etor_returns::default();
                                                                C::uextend_maybe_etor(ctx, v79.2, &mut v1930);
                                                                let mut v1930 = v1930.into_context_iter();
                                                                while let Some(v1931) = v1930.next(ctx) {
                                                                    if v2.0 == v1931.0 {
                                                                        let mut v1934 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v1931.1, &mut v1934);
                                                                        let mut v1934 = v1934.into_context_iter();
                                                                        while let Some(v1935) = v1934.next(ctx) {
                                                                            if let &InstructionData::IntCompare {
                                                                                opcode: ref v1938,
                                                                                args: ref v1939,
                                                                                cond: ref v1940,
                                                                            } = &v1935.1 {
                                                                                if let &Opcode::Icmp = v1938 {
                                                                                    match v1940 {
                                                                                        &IntCC::NotEqual => {
                                                                                            if v84.0 == v1935.0 {
                                                                                                let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                                                let v1941 = C::unpack_value_array_2(ctx, v1939);
                                                                                                if v1503.0 == v1941.0 {
                                                                                                    if v1503.1 == v1941.1 {
                                                                                                        let v1944 = constructor_spaceship_u(ctx, v84.0, v1503.0, v1503.1);
                                                                                                        let v1945 = constructor_sextend_maybe(ctx, v2.0, v1944);
                                                                                                        // Rule at src/opts/spaceship.isle line 12.
                                                                                                        returns.extend(Some(v1945));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                        &IntCC::UnsignedGreaterThan => {
                                                                                            if v84.0 == v1935.0 {
                                                                                                let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                                                let v1941 = C::unpack_value_array_2(ctx, v1939);
                                                                                                if v1503.0 == v1941.0 {
                                                                                                    if v1503.1 == v1941.1 {
                                                                                                        let v1944 = constructor_spaceship_u(ctx, v84.0, v1503.0, v1503.1);
                                                                                                        let v1945 = constructor_sextend_maybe(ctx, v2.0, v1944);
                                                                                                        // Rule at src/opts/spaceship.isle line 18.
                                                                                                        returns.extend(Some(v1945));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                        _ => {}
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                if v79.1 == v1503.0 {
                                                    if v79.2 == v1503.1 {
                                                        let v1660 = constructor_umin(ctx, v2.0, v1503.0, v1503.1);
                                                        // Rule at src/opts/selects.isle line 31.
                                                        returns.extend(Some(v1660));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v79.1 == v1503.1 {
                                                    if v79.2 == v1503.0 {
                                                        let v1658 = constructor_umax(ctx, v2.0, v1503.0, v1503.1);
                                                        // Rule at src/opts/selects.isle line 37.
                                                        returns.extend(Some(v1658));
                                                        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 v1508,
                                                        args: ref v1509,
                                                        cond: ref v1510,
                                                    } = &v90.1 {
                                                        if let &Opcode::Icmp = v1508 {
                                                            match v1510 {
                                                                &IntCC::Equal => {
                                                                    if v2.0 == v90.0 {
                                                                        let mut v1516 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v79.2, &mut v1516);
                                                                        let mut v1516 = v1516.into_context_iter();
                                                                        while let Some(v1517) = v1516.next(ctx) {
                                                                            if let &InstructionData::UnaryImm {
                                                                                opcode: ref v1635,
                                                                                imm: v1636,
                                                                            } = &v1517.1 {
                                                                                if let &Opcode::Iconst = v1635 {
                                                                                    let v1637 = C::u64_from_imm64(ctx, v1636);
                                                                                    if v1637 == 0x1_u64 {
                                                                                        if v2.0 == v1517.0 {
                                                                                            let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                                            let v1511 = C::unpack_value_array_2(ctx, v1509);
                                                                                            if v1503.0 == v1511.0 {
                                                                                                if v1503.1 == v1511.1 {
                                                                                                    let v1773 = constructor_ule(ctx, v2.0, v1503.1, v1503.0);
                                                                                                    // Rule at src/opts/selects.isle line 158.
                                                                                                    returns.extend(Some(v1773));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                            if v1503.0 == v1511.1 {
                                                                                                if v1503.1 == v1511.0 {
                                                                                                    let v1773 = constructor_ule(ctx, v2.0, v1503.1, v1503.0);
                                                                                                    // Rule at src/opts/selects.isle line 154.
                                                                                                    returns.extend(Some(v1773));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &IntCC::UnsignedGreaterThan => {
                                                                    if v2.0 == v90.0 {
                                                                        let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                        let v1511 = C::unpack_value_array_2(ctx, v1509);
                                                                        if v1503.0 == v1511.1 {
                                                                            if v1503.1 == v1511.0 {
                                                                                let mut v1516 = C::inst_data_value_etor_returns::default();
                                                                                C::inst_data_value_etor(ctx, v79.2, &mut v1516);
                                                                                let mut v1516 = v1516.into_context_iter();
                                                                                while let Some(v1517) = v1516.next(ctx) {
                                                                                    if let &InstructionData::UnaryImm {
                                                                                        opcode: ref v1635,
                                                                                        imm: v1636,
                                                                                    } = &v1517.1 {
                                                                                        if let &Opcode::Iconst = v1635 {
                                                                                            let v1637 = C::u64_from_imm64(ctx, v1636);
                                                                                            if v1637 == 0x1_u64 {
                                                                                                if v2.0 == v1517.0 {
                                                                                                    let v1775 = constructor_ne(ctx, v2.0, v1503.1, v1503.0);
                                                                                                    // Rule at src/opts/selects.isle line 173.
                                                                                                    returns.extend(Some(v1775));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &IntCC::UnsignedLessThan => {
                                                                    if v2.0 == v90.0 {
                                                                        let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                        let v1511 = C::unpack_value_array_2(ctx, v1509);
                                                                        if v1503.0 == v1511.0 {
                                                                            if v1503.1 == v1511.1 {
                                                                                let mut v1516 = C::inst_data_value_etor_returns::default();
                                                                                C::inst_data_value_etor(ctx, v79.2, &mut v1516);
                                                                                let mut v1516 = v1516.into_context_iter();
                                                                                while let Some(v1517) = v1516.next(ctx) {
                                                                                    if let &InstructionData::UnaryImm {
                                                                                        opcode: ref v1635,
                                                                                        imm: v1636,
                                                                                    } = &v1517.1 {
                                                                                        if let &Opcode::Iconst = v1635 {
                                                                                            let v1637 = C::u64_from_imm64(ctx, v1636);
                                                                                            if v1637 == 0x1_u64 {
                                                                                                if v2.0 == v1517.0 {
                                                                                                    let v1775 = constructor_ne(ctx, v2.0, v1503.1, v1503.0);
                                                                                                    // Rule at src/opts/selects.isle line 177.
                                                                                                    returns.extend(Some(v1775));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                    }
                                                }
                                                let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                if v79.1 == v1503.0 {
                                                    if v79.2 == v1503.1 {
                                                        let v1660 = constructor_umin(ctx, v2.0, v1503.0, v1503.1);
                                                        // Rule at src/opts/selects.isle line 32.
                                                        returns.extend(Some(v1660));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v79.1 == v1503.1 {
                                                    if v79.2 == v1503.0 {
                                                        let v1658 = constructor_umax(ctx, v2.0, v1503.0, v1503.1);
                                                        // Rule at src/opts/selects.isle line 38.
                                                        returns.extend(Some(v1658));
                                                        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 v1632,
                                                imm: v1633,
                                            } = &v90.1 {
                                                if let &Opcode::Iconst = v1632 {
                                                    let v1634 = C::u64_from_imm64(ctx, v1633);
                                                    match v1634 {
                                                        0x0_u64 => {
                                                            let mut v1516 = C::inst_data_value_etor_returns::default();
                                                            C::inst_data_value_etor(ctx, v79.2, &mut v1516);
                                                            let mut v1516 = v1516.into_context_iter();
                                                            while let Some(v1517) = v1516.next(ctx) {
                                                                if let &InstructionData::UnaryImm {
                                                                    opcode: ref v1635,
                                                                    imm: v1636,
                                                                } = &v1517.1 {
                                                                    if let &Opcode::Iconst = v1635 {
                                                                        let v1637 = C::u64_from_imm64(ctx, v1636);
                                                                        let v1638 = C::u64_matches_non_zero(ctx, v1637);
                                                                        if let Some(v1639) = v1638 {
                                                                            if v1639 == true {
                                                                                let v1640 = &C::intcc_complement(ctx, v1502);
                                                                                let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                                                let v1641 = constructor_icmp(ctx, v84.0, v1640, v1503.0, v1503.1);
                                                                                let v1642 = constructor_select(ctx, v2.0, v1641, v79.2, v79.1);
                                                                                // Rule at src/opts/selects.isle line 8.
                                                                                returns.extend(Some(v1642));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        0x1_u64 => {
                                                            let mut v1516 = C::inst_data_value_etor_returns::default();
                                                            C::inst_data_value_etor(ctx, v79.2, &mut v1516);
                                                            let mut v1516 = v1516.into_context_iter();
                                                            while let Some(v1517) = v1516.next(ctx) {
                                                                if let &InstructionData::UnaryImm {
                                                                    opcode: ref v1635,
                                                                    imm: v1636,
                                                                } = &v1517.1 {
                                                                    if let &Opcode::Iconst = v1635 {
                                                                        let v1637 = C::u64_from_imm64(ctx, v1636);
                                                                        if v1637 == 0x0_u64 {
                                                                            let v1643 = constructor_uextend_maybe(ctx, v2.0, v79.0);
                                                                            // Rule at src/opts/selects.isle line 14.
                                                                            returns.extend(Some(v1643));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                            }
                                        }
                                        let mut v1644 = C::inst_data_value_tupled_etor_returns::default();
                                        C::inst_data_value_tupled_etor(ctx, v79.1, &mut v1644);
                                        let mut v1644 = v1644.into_context_iter();
                                        while let Some(v1645) = v1644.next(ctx) {
                                            let v1646 = C::iconst_sextend_etor(ctx, v1645);
                                            if let Some(v1647) = v1646 {
                                                if v1647.1 == -1_i64 {
                                                    let mut v1650 = C::inst_data_value_tupled_etor_returns::default();
                                                    C::inst_data_value_tupled_etor(ctx, v79.2, &mut v1650);
                                                    let mut v1650 = v1650.into_context_iter();
                                                    while let Some(v1651) = v1650.next(ctx) {
                                                        let v1652 = C::iconst_sextend_etor(ctx, v1651);
                                                        if let Some(v1653) = v1652 {
                                                            if v1653.1 == 0_i64 {
                                                                let v1656 = constructor_bmask(ctx, v2.0, v79.0);
                                                                // Rule at src/opts/selects.isle line 19.
                                                                returns.extend(Some(v1656));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v87,
                                    arg: v88,
                                } => {
                                    if let &Opcode::Uextend = v87 {
                                        let mut v1454 = C::inst_data_value_etor_returns::default();
                                        C::inst_data_value_etor(ctx, v88, &mut v1454);
                                        let mut v1454 = v1454.into_context_iter();
                                        while let Some(v1455) = v1454.next(ctx) {
                                            if let &InstructionData::IntCompare {
                                                opcode: ref v1458,
                                                args: ref v1459,
                                                cond: ref v1460,
                                            } = &v1455.1 {
                                                if let &Opcode::Icmp = v1458 {
                                                    let v1464 = constructor_select(ctx, v2.0, v88, v79.1, v79.2);
                                                    // Rule at src/opts/icmp.isle line 83.
                                                    returns.extend(Some(v1464));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v1066,
                                    imm: v1067,
                                } => {
                                    if let &Opcode::Iconst = v1066 {
                                        let v1068 = C::u64_from_imm64(ctx, v1067);
                                        if v1068 == 0x0_u64 {
                                            let v1072 = C::subsume(ctx, v79.2);
                                            // Rule at src/opts/cprop.isle line 228.
                                            returns.extend(Some(v1072));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        let v1069 = C::u64_matches_non_zero(ctx, v1068);
                                        if let Some(v1070) = v1069 {
                                            if v1070 == true {
                                                let v1071 = C::subsume(ctx, v79.1);
                                                // Rule at src/opts/cprop.isle line 226.
                                                returns.extend(Some(v1071));
                                                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 v1508,
                                    args: ref v1509,
                                    cond: ref v1510,
                                } => {
                                    if let &Opcode::Icmp = v1508 {
                                        if let &IntCC::Equal = v1510 {
                                            if v2.0 == v90.0 {
                                                let mut v1516 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v79.2, &mut v1516);
                                                let mut v1516 = v1516.into_context_iter();
                                                while let Some(v1517) = v1516.next(ctx) {
                                                    if let &InstructionData::IntCompare {
                                                        opcode: ref v1520,
                                                        args: ref v1521,
                                                        cond: ref v1522,
                                                    } = &v1517.1 {
                                                        if let &Opcode::Icmp = v1520 {
                                                            if let &IntCC::Equal = v1522 {
                                                                if v2.0 == v1517.0 {
                                                                    let v1523 = C::unpack_value_array_2(ctx, v1521);
                                                                    let mut v1801 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v1523.0, &mut v1801);
                                                                    let mut v1801 = v1801.into_context_iter();
                                                                    while let Some(v1802) = v1801.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v1805,
                                                                            imm: v1806,
                                                                        } = &v1802.1 {
                                                                            if let &Opcode::Iconst = v1805 {
                                                                                let v1511 = C::unpack_value_array_2(ctx, v1509);
                                                                                if v1511.0 == v1523.1 {
                                                                                    let v1807 = C::u64_from_imm64(ctx, v1806);
                                                                                    let v1808 = constructor_iconst_u(ctx, v1802.0, v1807);
                                                                                    let v1821 = constructor_select(ctx, v1802.0, v79.0, v1511.1, v1808);
                                                                                    let v1822 = constructor_eq(ctx, v2.0, v1511.0, v1821);
                                                                                    // Rule at src/opts/selects.isle line 193.
                                                                                    returns.extend(Some(v1822));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                                if v1511.1 == v1523.1 {
                                                                                    let v1807 = C::u64_from_imm64(ctx, v1806);
                                                                                    let v1808 = constructor_iconst_u(ctx, v1802.0, v1807);
                                                                                    let v1809 = constructor_select(ctx, v1802.0, v79.0, v1511.0, v1808);
                                                                                    let v1810 = constructor_eq(ctx, v2.0, v1511.1, v1809);
                                                                                    // Rule at src/opts/selects.isle line 191.
                                                                                    returns.extend(Some(v1810));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    let mut v1811 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v1523.1, &mut v1811);
                                                                    let mut v1811 = v1811.into_context_iter();
                                                                    while let Some(v1812) = v1811.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v1815,
                                                                            imm: v1816,
                                                                        } = &v1812.1 {
                                                                            if let &Opcode::Iconst = v1815 {
                                                                                let v1511 = C::unpack_value_array_2(ctx, v1509);
                                                                                if v1511.0 == v1523.0 {
                                                                                    let v1817 = C::u64_from_imm64(ctx, v1816);
                                                                                    let v1818 = constructor_iconst_u(ctx, v1812.0, v1817);
                                                                                    let v1823 = constructor_select(ctx, v1812.0, v79.0, v1511.1, v1818);
                                                                                    let v1824 = constructor_eq(ctx, v2.0, v1511.0, v1823);
                                                                                    // Rule at src/opts/selects.isle line 194.
                                                                                    returns.extend(Some(v1824));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                                if v1511.1 == v1523.0 {
                                                                                    let v1817 = C::u64_from_imm64(ctx, v1816);
                                                                                    let v1818 = constructor_iconst_u(ctx, v1812.0, v1817);
                                                                                    let v1819 = constructor_select(ctx, v1812.0, v79.0, v1511.0, v1818);
                                                                                    let v1820 = constructor_eq(ctx, v2.0, v1511.1, v1819);
                                                                                    // Rule at src/opts/selects.isle line 192.
                                                                                    returns.extend(Some(v1820));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::Ternary {
                                    opcode: ref v1719,
                                    args: ref v1720,
                                } => {
                                    if let &Opcode::Select = v1719 {
                                        if v2.0 == v90.0 {
                                            let v1721 = C::unpack_value_array_3(ctx, v1720);
                                            if v79.0 == v1721.0 {
                                                let v1725 = constructor_select(ctx, v2.0, v79.0, v1721.1, v79.2);
                                                // Rule at src/opts/selects.isle line 102.
                                                returns.extend(Some(v1725));
                                                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 v1516 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v79.2, &mut v1516);
                                                let mut v1516 = v1516.into_context_iter();
                                                while let Some(v1517) = v1516.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v1674,
                                                        arg: v1675,
                                                    } = &v1517.1 {
                                                        if let &Opcode::Uextend = v1674 {
                                                            if v2.0 == v1517.0 {
                                                                let v1673 = C::value_type(ctx, v94);
                                                                let v1676 = C::value_type(ctx, v1675);
                                                                if v1673 == v1676 {
                                                                    let v1677 = constructor_select(ctx, v1673, v79.0, v94, v1675);
                                                                    let v1678 = constructor_uextend(ctx, v2.0, v1677);
                                                                    // Rule at src/opts/selects.isle line 80.
                                                                    returns.extend(Some(v1678));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Sextend => {
                                            if v2.0 == v90.0 {
                                                let mut v1516 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v79.2, &mut v1516);
                                                let mut v1516 = v1516.into_context_iter();
                                                while let Some(v1517) = v1516.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v1674,
                                                        arg: v1675,
                                                    } = &v1517.1 {
                                                        if let &Opcode::Sextend = v1674 {
                                                            if v2.0 == v1517.0 {
                                                                let v1673 = C::value_type(ctx, v94);
                                                                let v1676 = C::value_type(ctx, v1675);
                                                                if v1673 == v1676 {
                                                                    let v1677 = constructor_select(ctx, v1673, v79.0, v94, v1675);
                                                                    let v1679 = constructor_sextend(ctx, v2.0, v1677);
                                                                    // Rule at src/opts/selects.isle line 84.
                                                                    returns.extend(Some(v1679));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v1632,
                                    imm: v1633,
                                } => {
                                    if let &Opcode::Iconst = v1632 {
                                        let v1634 = C::u64_from_imm64(ctx, v1633);
                                        if v1634 == 0x1_u64 {
                                            if v2.0 == v90.0 {
                                                let mut v1516 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v79.2, &mut v1516);
                                                let mut v1516 = v1516.into_context_iter();
                                                while let Some(v1517) = v1516.next(ctx) {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v1758,
                                                        args: ref v1759,
                                                    } = &v1517.1 {
                                                        if let &Opcode::Bor = v1758 {
                                                            if v2.0 == v1517.0 {
                                                                let v1760 = C::unpack_value_array_2(ctx, v1759);
                                                                if v79.0 == v1760.0 {
                                                                    let v340 = constructor_iconst_u(ctx, v2.0, 0x1_u64);
                                                                    let v1776 = constructor_select(ctx, v2.0, v79.0, v340, v1760.1);
                                                                    // Rule at src/opts/selects.isle line 180.
                                                                    returns.extend(Some(v1776));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v79.0 == v1760.1 {
                                                                    let v340 = constructor_iconst_u(ctx, v2.0, 0x1_u64);
                                                                    let v1777 = constructor_select(ctx, v2.0, v79.0, v340, v1760.0);
                                                                    // Rule at src/opts/selects.isle line 181.
                                                                    returns.extend(Some(v1777));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                        if v79.1 == v79.2 {
                            let v1071 = C::subsume(ctx, v79.1);
                            // Rule at src/opts/selects.isle line 3.
                            returns.extend(Some(v1071));
                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                        }
                        let mut v382 = ContextIterWrapper::<ConstructorVec<_>, _>::default();
                        constructor_truthy(ctx, v79.0, &mut v382);
                        let mut v382 = v382.into_context_iter();
                        while let Some(v383) = v382.next(ctx) {
                            let v384 = constructor_select(ctx, v2.0, v383, v79.1, v79.2);
                            // Rule at src/opts/bitops.isle line 120.
                            returns.extend(Some(v384));
                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                        }
                        let mut v1516 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v79.2, &mut v1516);
                        let mut v1516 = v1516.into_context_iter();
                        while let Some(v1517) = v1516.next(ctx) {
                            if let &InstructionData::Ternary {
                                opcode: ref v1712,
                                args: ref v1713,
                            } = &v1517.1 {
                                if let &Opcode::Select = v1712 {
                                    if v2.0 == v1517.0 {
                                        let v1714 = C::unpack_value_array_3(ctx, v1713);
                                        if v79.0 == v1714.0 {
                                            let v1718 = constructor_select(ctx, v2.0, v79.0, v79.1, v1714.2);
                                            // Rule at src/opts/selects.isle line 101.
                                            returns.extend(Some(v1718));
                                            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 v1066,
                                imm: v1067,
                            } = &v84.1 {
                                if let &Opcode::Iconst = v1066 {
                                    let v1068 = C::u64_from_imm64(ctx, v1067);
                                    if v1068 == 0x0_u64 {
                                        let v1072 = C::subsume(ctx, v79.2);
                                        // Rule at src/opts/spectre.isle line 13.
                                        returns.extend(Some(v1072));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                    let v1069 = C::u64_matches_non_zero(ctx, v1068);
                                    if let Some(v1070) = v1069 {
                                        if v1070 == true {
                                            let v1071 = C::subsume(ctx, v79.1);
                                            // Rule at src/opts/spectre.isle line 11.
                                            returns.extend(Some(v1071));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                            }
                        }
                        if v79.1 == v79.2 {
                            let v1071 = C::subsume(ctx, v79.1);
                            // Rule at src/opts/spectre.isle line 9.
                            returns.extend(Some(v1071));
                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                        }
                    }
                    &Opcode::Bitselect => {
                        let v1661 = C::multi_lane(ctx, v2.0);
                        if let Some(v1662) = v1661 {
                            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 v1500,
                                    args: ref v1501,
                                    cond: ref v1502,
                                } = &v84.1 {
                                    if let &Opcode::Icmp = v1500 {
                                        match v1502 {
                                            &IntCC::SignedGreaterThan => {
                                                let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                if v79.1 == v1503.0 {
                                                    if v79.2 == v1503.1 {
                                                        let v1657 = constructor_smax(ctx, v2.0, v1503.0, v1503.1);
                                                        // Rule at src/opts/selects.isle line 45.
                                                        returns.extend(Some(v1657));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v79.1 == v1503.1 {
                                                    if v79.2 == v1503.0 {
                                                        let v1659 = constructor_smin(ctx, v2.0, v1503.0, v1503.1);
                                                        // Rule at src/opts/selects.isle line 59.
                                                        returns.extend(Some(v1659));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::SignedGreaterThanOrEqual => {
                                                let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                if v79.1 == v1503.0 {
                                                    if v79.2 == v1503.1 {
                                                        let v1657 = constructor_smax(ctx, v2.0, v1503.0, v1503.1);
                                                        // Rule at src/opts/selects.isle line 46.
                                                        returns.extend(Some(v1657));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v79.1 == v1503.1 {
                                                    if v79.2 == v1503.0 {
                                                        let v1659 = constructor_smin(ctx, v2.0, v1503.0, v1503.1);
                                                        // Rule at src/opts/selects.isle line 60.
                                                        returns.extend(Some(v1659));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::SignedLessThan => {
                                                let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                if v79.1 == v1503.0 {
                                                    if v79.2 == v1503.1 {
                                                        let v1659 = constructor_smin(ctx, v2.0, v1503.0, v1503.1);
                                                        // Rule at src/opts/selects.isle line 49.
                                                        returns.extend(Some(v1659));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v79.1 == v1503.1 {
                                                    if v79.2 == v1503.0 {
                                                        let v1657 = constructor_smax(ctx, v2.0, v1503.0, v1503.1);
                                                        // Rule at src/opts/selects.isle line 55.
                                                        returns.extend(Some(v1657));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::SignedLessThanOrEqual => {
                                                let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                if v79.1 == v1503.0 {
                                                    if v79.2 == v1503.1 {
                                                        let v1659 = constructor_smin(ctx, v2.0, v1503.0, v1503.1);
                                                        // Rule at src/opts/selects.isle line 50.
                                                        returns.extend(Some(v1659));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v79.1 == v1503.1 {
                                                    if v79.2 == v1503.0 {
                                                        let v1657 = constructor_smax(ctx, v2.0, v1503.0, v1503.1);
                                                        // Rule at src/opts/selects.isle line 56.
                                                        returns.extend(Some(v1657));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::UnsignedGreaterThan => {
                                                let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                if v79.1 == v1503.0 {
                                                    if v79.2 == v1503.1 {
                                                        let v1658 = constructor_umax(ctx, v2.0, v1503.0, v1503.1);
                                                        // Rule at src/opts/selects.isle line 47.
                                                        returns.extend(Some(v1658));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v79.1 == v1503.1 {
                                                    if v79.2 == v1503.0 {
                                                        let v1660 = constructor_umin(ctx, v2.0, v1503.0, v1503.1);
                                                        // Rule at src/opts/selects.isle line 61.
                                                        returns.extend(Some(v1660));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::UnsignedGreaterThanOrEqual => {
                                                let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                if v79.1 == v1503.0 {
                                                    if v79.2 == v1503.1 {
                                                        let v1658 = constructor_umax(ctx, v2.0, v1503.0, v1503.1);
                                                        // Rule at src/opts/selects.isle line 48.
                                                        returns.extend(Some(v1658));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v79.1 == v1503.1 {
                                                    if v79.2 == v1503.0 {
                                                        let v1660 = constructor_umin(ctx, v2.0, v1503.0, v1503.1);
                                                        // Rule at src/opts/selects.isle line 62.
                                                        returns.extend(Some(v1660));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::UnsignedLessThan => {
                                                let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                if v79.1 == v1503.0 {
                                                    if v79.2 == v1503.1 {
                                                        let v1660 = constructor_umin(ctx, v2.0, v1503.0, v1503.1);
                                                        // Rule at src/opts/selects.isle line 51.
                                                        returns.extend(Some(v1660));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v79.1 == v1503.1 {
                                                    if v79.2 == v1503.0 {
                                                        let v1658 = constructor_umax(ctx, v2.0, v1503.0, v1503.1);
                                                        // Rule at src/opts/selects.isle line 57.
                                                        returns.extend(Some(v1658));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::UnsignedLessThanOrEqual => {
                                                let v1503 = C::unpack_value_array_2(ctx, v1501);
                                                if v79.1 == v1503.0 {
                                                    if v79.2 == v1503.1 {
                                                        let v1660 = constructor_umin(ctx, v2.0, v1503.0, v1503.1);
                                                        // Rule at src/opts/selects.isle line 52.
                                                        returns.extend(Some(v1660));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v79.1 == v1503.1 {
                                                    if v79.2 == v1503.0 {
                                                        let v1658 = constructor_umax(ctx, v2.0, v1503.0, v1503.1);
                                                        // Rule at src/opts/selects.isle line 58.
                                                        returns.extend(Some(v1658));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                }
                            }
                        }
                        let v79 = C::unpack_value_array_3(ctx, v78);
                        if v79.1 == v79.2 {
                            let v1071 = C::subsume(ctx, v79.1);
                            // Rule at src/opts/selects.isle line 4.
                            returns.extend(Some(v1071));
                            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 v1099 = C::ty_vec128(ctx, v2.0);
                        if let Some(v1100) = v1099 {
                            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 v1116,
                                        imm: v1117,
                                    } => {
                                        if let &Opcode::F32const = v1116 {
                                            let v1118 = C::u32_from_ieee32(ctx, v1117);
                                            let v1119 = C::u32_into_u64(ctx, v1118);
                                            let v1120 = constructor_splat32(ctx, v1119);
                                            let v1121 = constructor_vconst(ctx, v1100, v1120);
                                            // Rule at src/opts/cprop.isle line 283.
                                            returns.extend(Some(v1121));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                    &InstructionData::UnaryIeee64 {
                                        opcode: ref v1122,
                                        imm: v1123,
                                    } => {
                                        if let &Opcode::F64const = v1122 {
                                            let v1124 = C::u64_from_ieee64(ctx, v1123);
                                            let v1125 = C::splat64(ctx, v1124);
                                            let v1126 = constructor_vconst(ctx, v1100, v1125);
                                            // Rule at src/opts/cprop.isle line 285.
                                            returns.extend(Some(v1126));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                    &InstructionData::UnaryImm {
                                        opcode: ref v953,
                                        imm: v954,
                                    } => {
                                        if let &Opcode::Iconst = v953 {
                                            match v35.0 {
                                                I8 => {
                                                    let v1101 = C::u64_uextend_imm64(ctx, I8, v954);
                                                    let v1102 = constructor_splat8(ctx, v1101);
                                                    let v1103 = constructor_vconst(ctx, v1100, v1102);
                                                    // Rule at src/opts/cprop.isle line 275.
                                                    returns.extend(Some(v1103));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                I16 => {
                                                    let v1105 = C::u64_uextend_imm64(ctx, I16, v954);
                                                    let v1106 = constructor_splat16(ctx, v1105);
                                                    let v1107 = constructor_vconst(ctx, v1100, v1106);
                                                    // Rule at src/opts/cprop.isle line 277.
                                                    returns.extend(Some(v1107));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                I32 => {
                                                    let v1109 = C::u64_uextend_imm64(ctx, I32, v954);
                                                    let v1110 = constructor_splat32(ctx, v1109);
                                                    let v1111 = constructor_vconst(ctx, v1100, v1110);
                                                    // Rule at src/opts/cprop.isle line 279.
                                                    returns.extend(Some(v1111));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                I64 => {
                                                    let v1113 = C::u64_uextend_imm64(ctx, I64, v954);
                                                    let v1114 = C::splat64(ctx, v1113);
                                                    let v1115 = constructor_vconst(ctx, v1100, v1114);
                                                    // Rule at src/opts/cprop.isle line 281.
                                                    returns.extend(Some(v1115));
                                                    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 v1355,
                                                        imm: v1356,
                                                    } = &v312.1 {
                                                        if let &Opcode::Iconst = v1355 {
                                                            let v1851 = C::u64_from_imm64(ctx, v1356);
                                                            let v367 = constructor_ty_shift_mask(ctx, v2.0);
                                                            let v1852 = C::u64_eq(ctx, v1851, v367);
                                                            if v1852 == true {
                                                                if v2.0 == v312.0 {
                                                                    let v1853 = constructor_sshr(ctx, v2.0, v40.0, v40.1);
                                                                    // Rule at src/opts/shifts.isle line 98.
                                                                    returns.extend(Some(v1853));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v45,
                                    arg: v46,
                                } => {
                                    match v45 {
                                        &Opcode::Splat => {
                                            if v2.0 == v35.0 {
                                                let v1869 = C::lane_type(ctx, v2.0);
                                                let v2026 = constructor_ineg(ctx, v1869, v46);
                                                let v2027 = constructor_splat(ctx, v2.0, v2026);
                                                // Rule at src/opts/vector.isle line 45.
                                                returns.extend(Some(v2027));
                                                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::Bnot => {
                                            if v2.0 == v35.0 {
                                                let v340 = constructor_iconst_u(ctx, v2.0, 0x1_u64);
                                                let v341 = constructor_iadd(ctx, v2.0, v46, v340);
                                                // Rule at src/opts/arithmetic.isle line 572.
                                                returns.extend(Some(v341));
                                                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 v1869 = C::lane_type(ctx, v2.0);
                                            let v2028 = constructor_iabs(ctx, v1869, v46);
                                            let v2029 = constructor_splat(ctx, v2.0, v2028);
                                            // Rule at src/opts/vector.isle line 48.
                                            returns.extend(Some(v2029));
                                            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 v795 = constructor_isub(ctx, v2.0, v309, v40.1);
                                                                // Rule at src/opts/bitops.isle line 418.
                                                                returns.extend(Some(v795));
                                                                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 v796 = constructor_isub(ctx, v2.0, v316, v40.0);
                                                                // Rule at src/opts/bitops.isle line 419.
                                                                returns.extend(Some(v796));
                                                                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 v1355,
                                                            imm: v1356,
                                                        } = &v312.1 {
                                                            if let &Opcode::Iconst = v1355 {
                                                                if v35.0 == v312.0 {
                                                                    let v1357 = constructor_bnot(ctx, v335, v40.0);
                                                                    let v1358 = C::imm64_neg(ctx, v335, v1356);
                                                                    let v1359 = constructor_iconst(ctx, v335, v1358);
                                                                    let v1360 = constructor_iadd(ctx, v335, v1357, v1359);
                                                                    // Rule at src/opts/cprop.isle line 520.
                                                                    returns.extend(Some(v1360));
                                                                    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 v772 = constructor_bnot(ctx, v2.0, v40.1);
                                                                let v773 = constructor_bor(ctx, v2.0, v309, v772);
                                                                // Rule at src/opts/bitops.isle line 359.
                                                                returns.extend(Some(v773));
                                                                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 v774 = constructor_bnot(ctx, v2.0, v40.0);
                                                                let v775 = constructor_bor(ctx, v2.0, v316, v774);
                                                                // Rule at src/opts/bitops.isle line 360.
                                                                returns.extend(Some(v775));
                                                                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 v772 = constructor_bnot(ctx, v2.0, v40.1);
                                                                let v776 = constructor_band(ctx, v2.0, v309, v772);
                                                                // Rule at src/opts/bitops.isle line 363.
                                                                returns.extend(Some(v776));
                                                                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 v774 = constructor_bnot(ctx, v2.0, v40.0);
                                                                let v777 = constructor_band(ctx, v2.0, v316, v774);
                                                                // Rule at src/opts/bitops.isle line 364.
                                                                returns.extend(Some(v777));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v45,
                                    arg: v46,
                                } => {
                                    match v45 {
                                        &Opcode::Splat => {
                                            let v2006 = C::ty_vector_not_float(ctx, v2.0);
                                            if let Some(v2007) = v2006 {
                                                if v2.0 == v35.0 {
                                                    let v1869 = C::lane_type(ctx, v2.0);
                                                    let v2014 = constructor_bnot(ctx, v1869, v46);
                                                    let v2015 = constructor_splat(ctx, v2.0, v2014);
                                                    // Rule at src/opts/vector.isle line 26.
                                                    returns.extend(Some(v2015));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        &Opcode::Ineg => {
                                            if v2.0 == v35.0 {
                                                let v340 = constructor_iconst_u(ctx, v2.0, 0x1_u64);
                                                let v342 = constructor_isub(ctx, v2.0, v46, v340);
                                                // Rule at src/opts/arithmetic.isle line 575.
                                                returns.extend(Some(v342));
                                                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 49.
                                                returns.extend(Some(v47));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v953,
                                    imm: v954,
                                } => {
                                    if let &Opcode::Iconst = v953 {
                                        let v334 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v335) = v334 {
                                            if v35.0 == v335 {
                                                let v979 = C::imm64_not(ctx, v335, v954);
                                                let v980 = constructor_iconst(ctx, v335, v979);
                                                let v981 = C::subsume(ctx, v980);
                                                // Rule at src/opts/cprop.isle line 73.
                                                returns.extend(Some(v981));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                        let v1625 = C::remat(ctx, arg0);
                        // Rule at src/opts/remat.isle line 23.
                        returns.extend(Some(v1625));
                        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 139.
                                        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 v953,
                                    imm: v954,
                                } = &v35.1 {
                                    if let &Opcode::Iconst = v953 {
                                        if v35.0 == v335 {
                                            let v955 = C::imm64_clz(ctx, v335, v954);
                                            let v956 = constructor_iconst(ctx, v335, v955);
                                            let v957 = C::subsume(ctx, v956);
                                            // Rule at src/opts/cprop.isle line 2.
                                            returns.extend(Some(v957));
                                            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 v953,
                                    imm: v954,
                                } = &v35.1 {
                                    if let &Opcode::Iconst = v953 {
                                        if v35.0 == v335 {
                                            let v958 = C::imm64_ctz(ctx, v335, v954);
                                            let v959 = constructor_iconst(ctx, v335, v958);
                                            let v960 = C::subsume(ctx, v959);
                                            // Rule at src/opts/cprop.isle line 8.
                                            returns.extend(Some(v960));
                                            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 136.
                                            returns.extend(Some(v47));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v953,
                                    imm: v954,
                                } => {
                                    if let &Opcode::Iconst = v953 {
                                        match v2.0 {
                                            I16 => {
                                                let v1011 = C::u64_from_imm64(ctx, v954);
                                                let v1172 = C::u64_bswap16(ctx, v1011);
                                                let v1173 = C::imm64(ctx, v1172);
                                                let v1174 = constructor_iconst(ctx, I16, v1173);
                                                let v1175 = C::subsume(ctx, v1174);
                                                // Rule at src/opts/cprop.isle line 374.
                                                returns.extend(Some(v1175));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            I32 => {
                                                let v1011 = C::u64_from_imm64(ctx, v954);
                                                let v1176 = C::u64_bswap32(ctx, v1011);
                                                let v1177 = C::imm64(ctx, v1176);
                                                let v1178 = constructor_iconst(ctx, I32, v1177);
                                                let v1179 = C::subsume(ctx, v1178);
                                                // Rule at src/opts/cprop.isle line 376.
                                                returns.extend(Some(v1179));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            I64 => {
                                                let v1011 = C::u64_from_imm64(ctx, v954);
                                                let v1180 = C::u64_bswap64(ctx, v1011);
                                                let v1181 = C::imm64(ctx, v1180);
                                                let v1182 = constructor_iconst(ctx, I64, v1181);
                                                let v1183 = C::subsume(ctx, v1182);
                                                // Rule at src/opts/cprop.isle line 378.
                                                returns.extend(Some(v1183));
                                                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 v1869 = C::lane_type(ctx, v2.0);
                                        let v2030 = constructor_popcnt(ctx, v1869, v46);
                                        let v2031 = constructor_splat(ctx, v2.0, v2030);
                                        // Rule at src/opts/vector.isle line 51.
                                        returns.extend(Some(v2031));
                                        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 v1116,
                                            imm: v1117,
                                        } = &v35.1 {
                                            if let &Opcode::F32const = v1116 {
                                                let v1224 = C::f32_sqrt(ctx, v1117);
                                                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 425.
                                                    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 v1122,
                                            imm: v1123,
                                        } = &v35.1 {
                                            if let &Opcode::F64const = v1122 {
                                                let v1228 = C::f64_sqrt(ctx, v1123);
                                                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 428.
                                                    returns.extend(Some(v1231));
                                                    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 v1321,
                                    constant_handle: v1322,
                                } => {
                                    if let &Opcode::F128const = v1321 {
                                        if v2.0 == F128 {
                                            if v35.0 == F128 {
                                                let v1323 = C::ieee128_constant_extractor(ctx, v1322);
                                                if let Some(v1324) = v1323 {
                                                    let v1325 = C::f128_neg(ctx, v1324);
                                                    let v1326 = C::ieee128_constant(ctx, v1325);
                                                    let v1327 = constructor_f128const(ctx, F128, v1326);
                                                    let v1328 = C::subsume(ctx, v1327);
                                                    // Rule at src/opts/cprop.isle line 492.
                                                    returns.extend(Some(v1328));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryIeee16 {
                                    opcode: ref v1132,
                                    imm: v1133,
                                } => {
                                    if let &Opcode::F16const = v1132 {
                                        if v2.0 == F16 {
                                            if v35.0 == F16 {
                                                let v1312 = C::f16_neg(ctx, v1133);
                                                let v1313 = constructor_f16const(ctx, F16, v1312);
                                                let v1314 = C::subsume(ctx, v1313);
                                                // Rule at src/opts/cprop.isle line 486.
                                                returns.extend(Some(v1314));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryIeee32 {
                                    opcode: ref v1116,
                                    imm: v1117,
                                } => {
                                    if let &Opcode::F32const = v1116 {
                                        if v2.0 == F32 {
                                            if v35.0 == F32 {
                                                let v1315 = C::f32_neg(ctx, v1117);
                                                let v1316 = constructor_f32const(ctx, F32, v1315);
                                                let v1317 = C::subsume(ctx, v1316);
                                                // Rule at src/opts/cprop.isle line 488.
                                                returns.extend(Some(v1317));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryIeee64 {
                                    opcode: ref v1122,
                                    imm: v1123,
                                } => {
                                    if let &Opcode::F64const = v1122 {
                                        if v2.0 == F64 {
                                            if v35.0 == F64 {
                                                let v1318 = C::f64_neg(ctx, v1123);
                                                let v1319 = constructor_f64const(ctx, F64, v1318);
                                                let v1320 = C::subsume(ctx, v1319);
                                                // Rule at src/opts/cprop.isle line 490.
                                                returns.extend(Some(v1320));
                                                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 v1132,
                                            imm: v1133,
                                        } = &v35.1 {
                                            if let &Opcode::F16const = v1132 {
                                                let v1329 = C::f16_abs(ctx, v1133);
                                                let v1330 = constructor_f16const(ctx, F16, v1329);
                                                let v1331 = C::subsume(ctx, v1330);
                                                // Rule at src/opts/cprop.isle line 495.
                                                returns.extend(Some(v1331));
                                                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 v1116,
                                            imm: v1117,
                                        } = &v35.1 {
                                            if let &Opcode::F32const = v1116 {
                                                let v1332 = C::f32_abs(ctx, v1117);
                                                let v1333 = constructor_f32const(ctx, F32, v1332);
                                                let v1334 = C::subsume(ctx, v1333);
                                                // Rule at src/opts/cprop.isle line 497.
                                                returns.extend(Some(v1334));
                                                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 v1122,
                                            imm: v1123,
                                        } = &v35.1 {
                                            if let &Opcode::F64const = v1122 {
                                                let v1335 = C::f64_abs(ctx, v1123);
                                                let v1336 = constructor_f64const(ctx, F64, v1335);
                                                let v1337 = C::subsume(ctx, v1336);
                                                // Rule at src/opts/cprop.isle line 499.
                                                returns.extend(Some(v1337));
                                                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 v1321,
                                            constant_handle: v1322,
                                        } = &v35.1 {
                                            if let &Opcode::F128const = v1321 {
                                                let v1323 = C::ieee128_constant_extractor(ctx, v1322);
                                                if let Some(v1324) = v1323 {
                                                    let v1338 = C::f128_abs(ctx, v1324);
                                                    let v1339 = C::ieee128_constant(ctx, v1338);
                                                    let v1340 = constructor_f128const(ctx, F128, v1339);
                                                    let v1341 = C::subsume(ctx, v1340);
                                                    // Rule at src/opts/cprop.isle line 501.
                                                    returns.extend(Some(v1341));
                                                    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 v1116,
                                            imm: v1117,
                                        } = &v35.1 {
                                            if let &Opcode::F32const = v1116 {
                                                let v1232 = C::f32_ceil(ctx, v1117);
                                                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 432.
                                                    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 v1122,
                                            imm: v1123,
                                        } = &v35.1 {
                                            if let &Opcode::F64const = v1122 {
                                                let v1236 = C::f64_ceil(ctx, v1123);
                                                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 435.
                                                    returns.extend(Some(v1239));
                                                    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 v1116,
                                            imm: v1117,
                                        } = &v35.1 {
                                            if let &Opcode::F32const = v1116 {
                                                let v1240 = C::f32_floor(ctx, v1117);
                                                if let Some(v1241) = v1240 {
                                                    let v1242 = constructor_f32const(ctx, F32, v1241);
                                                    let v1243 = C::subsume(ctx, v1242);
                                                    // Rule at src/opts/cprop.isle line 439.
                                                    returns.extend(Some(v1243));
                                                    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 v1122,
                                            imm: v1123,
                                        } = &v35.1 {
                                            if let &Opcode::F64const = v1122 {
                                                let v1244 = C::f64_floor(ctx, v1123);
                                                if let Some(v1245) = v1244 {
                                                    let v1246 = constructor_f64const(ctx, F64, v1245);
                                                    let v1247 = C::subsume(ctx, v1246);
                                                    // Rule at src/opts/cprop.isle line 442.
                                                    returns.extend(Some(v1247));
                                                    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 v1116,
                                            imm: v1117,
                                        } = &v35.1 {
                                            if let &Opcode::F32const = v1116 {
                                                let v1248 = C::f32_trunc(ctx, v1117);
                                                if let Some(v1249) = v1248 {
                                                    let v1250 = constructor_f32const(ctx, F32, v1249);
                                                    let v1251 = C::subsume(ctx, v1250);
                                                    // Rule at src/opts/cprop.isle line 446.
                                                    returns.extend(Some(v1251));
                                                    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 v1122,
                                            imm: v1123,
                                        } = &v35.1 {
                                            if let &Opcode::F64const = v1122 {
                                                let v1252 = C::f64_trunc(ctx, v1123);
                                                if let Some(v1253) = v1252 {
                                                    let v1254 = constructor_f64const(ctx, F64, v1253);
                                                    let v1255 = C::subsume(ctx, v1254);
                                                    // Rule at src/opts/cprop.isle line 449.
                                                    returns.extend(Some(v1255));
                                                    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 v1116,
                                            imm: v1117,
                                        } = &v35.1 {
                                            if let &Opcode::F32const = v1116 {
                                                let v1256 = C::f32_nearest(ctx, v1117);
                                                if let Some(v1257) = v1256 {
                                                    let v1258 = constructor_f32const(ctx, F32, v1257);
                                                    let v1259 = C::subsume(ctx, v1258);
                                                    // Rule at src/opts/cprop.isle line 453.
                                                    returns.extend(Some(v1259));
                                                    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 v1122,
                                            imm: v1123,
                                        } = &v35.1 {
                                            if let &Opcode::F64const = v1122 {
                                                let v1260 = C::f64_nearest(ctx, v1123);
                                                if let Some(v1261) = v1260 {
                                                    let v1262 = constructor_f64const(ctx, F64, v1261);
                                                    let v1263 = C::subsume(ctx, v1262);
                                                    // Rule at src/opts/cprop.isle line 456.
                                                    returns.extend(Some(v1263));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            _ => {}
                        }
                    }
                    &Opcode::ScalarToVector => {
                        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::UnaryIeee16 {
                                    opcode: ref v1132,
                                    imm: v1133,
                                } => {
                                    if let &Opcode::F16const = v1132 {
                                        let v1099 = C::ty_vec128(ctx, v2.0);
                                        if let Some(v1100) = v1099 {
                                            let v1134 = C::u16_from_ieee16(ctx, v1133);
                                            let v1135 = C::u16_into_u64(ctx, v1134);
                                            let v1136 = C::scalar_to_vector_const64(ctx, v1135);
                                            let v1137 = constructor_vconst(ctx, v1100, v1136);
                                            // Rule at src/opts/cprop.isle line 303.
                                            returns.extend(Some(v1137));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                                &InstructionData::UnaryIeee32 {
                                    opcode: ref v1116,
                                    imm: v1117,
                                } => {
                                    if let &Opcode::F32const = v1116 {
                                        let v1099 = C::ty_vec128(ctx, v2.0);
                                        if let Some(v1100) = v1099 {
                                            let v1118 = C::u32_from_ieee32(ctx, v1117);
                                            let v1119 = C::u32_into_u64(ctx, v1118);
                                            let v1138 = C::scalar_to_vector_const64(ctx, v1119);
                                            let v1139 = constructor_vconst(ctx, v1100, v1138);
                                            // Rule at src/opts/cprop.isle line 306.
                                            returns.extend(Some(v1139));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                                &InstructionData::UnaryIeee64 {
                                    opcode: ref v1122,
                                    imm: v1123,
                                } => {
                                    if let &Opcode::F64const = v1122 {
                                        let v1099 = C::ty_vec128(ctx, v2.0);
                                        if let Some(v1100) = v1099 {
                                            let v1124 = C::u64_from_ieee64(ctx, v1123);
                                            let v1140 = C::scalar_to_vector_const64(ctx, v1124);
                                            let v1141 = constructor_vconst(ctx, v1100, v1140);
                                            // Rule at src/opts/cprop.isle line 309.
                                            returns.extend(Some(v1141));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v953,
                                    imm: v954,
                                } => {
                                    if let &Opcode::Iconst = v953 {
                                        let v1127 = C::ty_vec128_int(ctx, v2.0);
                                        if let Some(v1128) = v1127 {
                                            let v1129 = C::u64_uextend_imm64(ctx, v35.0, v954);
                                            let v1130 = C::scalar_to_vector_const64(ctx, v1129);
                                            let v1131 = constructor_vconst(ctx, v1128, v1130);
                                            // Rule at src/opts/cprop.isle line 301.
                                            returns.extend(Some(v1131));
                                            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 v371,
                                        args: ref v372,
                                        cond: ref v373,
                                    } = &v35.1 {
                                        if let &Opcode::Icmp = v371 {
                                            let v378 = constructor_ineg(ctx, I8, v33);
                                            // Rule at src/opts/bitops.isle line 97.
                                            returns.extend(Some(v378));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                            }
                        }
                        let mut v379 = ContextIterWrapper::<ConstructorVec<_>, _>::default();
                        constructor_truthy(ctx, v33, &mut v379);
                        let mut v379 = v379.into_context_iter();
                        while let Some(v380) = v379.next(ctx) {
                            let v381 = constructor_bmask(ctx, v2.0, v380);
                            // Rule at src/opts/bitops.isle line 119.
                            returns.extend(Some(v381));
                            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 v1405 = constructor_ireduce(ctx, v2.0, v40.0);
                                            let v1406 = constructor_ireduce(ctx, v2.0, v40.1);
                                            let v1407 = constructor_iadd(ctx, v2.0, v1405, v1406);
                                            // Rule at src/opts/extends.isle line 85.
                                            returns.extend(Some(v1407));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Isub => {
                                            let v40 = C::unpack_value_array_2(ctx, v39);
                                            let v1405 = constructor_ireduce(ctx, v2.0, v40.0);
                                            let v1406 = constructor_ireduce(ctx, v2.0, v40.1);
                                            let v1408 = constructor_isub(ctx, v2.0, v1405, v1406);
                                            // Rule at src/opts/extends.isle line 86.
                                            returns.extend(Some(v1408));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Imul => {
                                            let v40 = C::unpack_value_array_2(ctx, v39);
                                            let v1405 = constructor_ireduce(ctx, v2.0, v40.0);
                                            let v1406 = constructor_ireduce(ctx, v2.0, v40.1);
                                            let v1409 = constructor_imul(ctx, v2.0, v1405, v1406);
                                            // Rule at src/opts/extends.isle line 87.
                                            returns.extend(Some(v1409));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Band => {
                                            let v40 = C::unpack_value_array_2(ctx, v39);
                                            let v1405 = constructor_ireduce(ctx, v2.0, v40.0);
                                            let v1406 = constructor_ireduce(ctx, v2.0, v40.1);
                                            let v1412 = constructor_band(ctx, v2.0, v1405, v1406);
                                            // Rule at src/opts/extends.isle line 90.
                                            returns.extend(Some(v1412));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Bor => {
                                            let v40 = C::unpack_value_array_2(ctx, v39);
                                            let v1405 = constructor_ireduce(ctx, v2.0, v40.0);
                                            let v1406 = constructor_ireduce(ctx, v2.0, v40.1);
                                            let v1410 = constructor_bor(ctx, v2.0, v1405, v1406);
                                            // Rule at src/opts/extends.isle line 88.
                                            returns.extend(Some(v1410));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Bxor => {
                                            let v40 = C::unpack_value_array_2(ctx, v39);
                                            let v1405 = constructor_ireduce(ctx, v2.0, v40.0);
                                            let v1406 = constructor_ireduce(ctx, v2.0, v40.1);
                                            let v1411 = constructor_bxor(ctx, v2.0, v1405, v1406);
                                            // Rule at src/opts/extends.isle line 89.
                                            returns.extend(Some(v1411));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v45,
                                    arg: v46,
                                } => {
                                    match v45 {
                                        &Opcode::Ineg => {
                                            let v1402 = constructor_ireduce(ctx, v2.0, v46);
                                            let v1403 = constructor_ineg(ctx, v2.0, v1402);
                                            // Rule at src/opts/extends.isle line 82.
                                            returns.extend(Some(v1403));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Bnot => {
                                            let v1402 = constructor_ireduce(ctx, v2.0, v46);
                                            let v1404 = constructor_bnot(ctx, v2.0, v1402);
                                            // Rule at src/opts/extends.isle line 83.
                                            returns.extend(Some(v1404));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Bmask => {
                                            let v392 = constructor_bmask(ctx, v2.0, v46);
                                            // Rule at src/opts/bitops.isle line 133.
                                            returns.extend(Some(v392));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Ireduce => {
                                            let v1402 = constructor_ireduce(ctx, v2.0, v46);
                                            // Rule at src/opts/extends.isle line 97.
                                            returns.extend(Some(v1402));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Uextend => {
                                            let v1386 = C::ty_int(ctx, v2.0);
                                            if let Some(v1387) = v1386 {
                                                let v1388 = C::ty_bits_u64(ctx, v1387);
                                                let v1385 = C::value_type(ctx, v46);
                                                let v1389 = C::ty_bits_u64(ctx, v1385);
                                                let v1390 = C::u64_lt(ctx, v1388, v1389);
                                                if v1390 == true {
                                                    let v1391 = constructor_ireduce(ctx, v1387, v46);
                                                    // Rule at src/opts/extends.isle line 57.
                                                    returns.extend(Some(v1391));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let v1392 = C::u64_lt(ctx, v1389, v1388);
                                                if v1392 == true {
                                                    let v1394 = constructor_uextend(ctx, v1387, v46);
                                                    // Rule at src/opts/extends.isle line 64.
                                                    returns.extend(Some(v1394));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                            let v1385 = C::value_type(ctx, v46);
                                            if v2.0 == v1385 {
                                                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 v1386 = C::ty_int(ctx, v2.0);
                                            if let Some(v1387) = v1386 {
                                                let v1388 = C::ty_bits_u64(ctx, v1387);
                                                let v1385 = C::value_type(ctx, v46);
                                                let v1389 = C::ty_bits_u64(ctx, v1385);
                                                let v1390 = C::u64_lt(ctx, v1388, v1389);
                                                if v1390 == true {
                                                    let v1391 = constructor_ireduce(ctx, v1387, v46);
                                                    // Rule at src/opts/extends.isle line 54.
                                                    returns.extend(Some(v1391));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let v1392 = C::u64_lt(ctx, v1389, v1388);
                                                if v1392 == true {
                                                    let v1393 = constructor_sextend(ctx, v1387, v46);
                                                    // Rule at src/opts/extends.isle line 61.
                                                    returns.extend(Some(v1393));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                            let v1385 = C::value_type(ctx, v46);
                                            if v2.0 == v1385 {
                                                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 v953,
                                    imm: v954,
                                } => {
                                    if let &Opcode::Iconst = v953 {
                                        let v1009 = C::fits_in_64(ctx, v35.0);
                                        if let Some(v1010) = v1009 {
                                            let v1011 = C::u64_from_imm64(ctx, v954);
                                            let v1012 = C::imm64_masked(ctx, v2.0, v1011);
                                            let v1013 = constructor_iconst(ctx, v2.0, v1012);
                                            let v1014 = C::subsume(ctx, v1013);
                                            // Rule at src/opts/cprop.isle line 124.
                                            returns.extend(Some(v1014));
                                            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 v1869 = C::lane_type(ctx, v2.0);
                                    let v2050 = constructor_sextend(ctx, v1869, v46);
                                    let v2051 = constructor_splat(ctx, v2.0, v2050);
                                    // Rule at src/opts/vector.isle line 85.
                                    returns.extend(Some(v2051));
                                    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 v1869 = C::lane_type(ctx, v2.0);
                                    let v2050 = constructor_sextend(ctx, v1869, v46);
                                    let v2051 = constructor_splat(ctx, v2.0, v2050);
                                    // Rule at src/opts/vector.isle line 84.
                                    returns.extend(Some(v2051));
                                    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 v1869 = C::lane_type(ctx, v2.0);
                                    let v2052 = constructor_uextend(ctx, v1869, v46);
                                    let v2053 = constructor_splat(ctx, v2.0, v2052);
                                    // Rule at src/opts/vector.isle line 88.
                                    returns.extend(Some(v2053));
                                    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 v1869 = C::lane_type(ctx, v2.0);
                                    let v2052 = constructor_uextend(ctx, v1869, v46);
                                    let v2053 = constructor_splat(ctx, v2.0, v2052);
                                    // Rule at src/opts/vector.isle line 87.
                                    returns.extend(Some(v2053));
                                    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 v1361 = constructor_uextend(ctx, v2.0, v46);
                                        // Rule at src/opts/extends.isle line 1.
                                        returns.extend(Some(v1361));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v953,
                                    imm: v954,
                                } => {
                                    if let &Opcode::Iconst = v953 {
                                        let v334 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v335) = v334 {
                                            let v1011 = C::u64_from_imm64(ctx, v954);
                                            let v1015 = constructor_iconst_u(ctx, v335, v1011);
                                            let v1016 = C::subsume(ctx, v1015);
                                            // Rule at src/opts/cprop.isle line 129.
                                            returns.extend(Some(v1016));
                                            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 v371,
                                    args: ref v372,
                                    cond: ref v373,
                                } => {
                                    if let &Opcode::Icmp = v371 {
                                        let v1363 = constructor_uextend(ctx, v2.0, v33);
                                        // Rule at src/opts/extends.isle line 11.
                                        returns.extend(Some(v1363));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v45,
                                    arg: v46,
                                } => {
                                    match v45 {
                                        &Opcode::Bmask => {
                                            let v392 = constructor_bmask(ctx, v2.0, v46);
                                            // Rule at src/opts/bitops.isle line 132.
                                            returns.extend(Some(v392));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Uextend => {
                                            let v1361 = constructor_uextend(ctx, v2.0, v46);
                                            // Rule at src/opts/extends.isle line 7.
                                            returns.extend(Some(v1361));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Sextend => {
                                            let v1362 = constructor_sextend(ctx, v2.0, v46);
                                            // Rule at src/opts/extends.isle line 3.
                                            returns.extend(Some(v1362));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        _ => {}
                                    }
                                }
                                _ => {}
                            }
                        }
                        let v334 = C::fits_in_64(ctx, v2.0);
                        if let Some(v335) = v334 {
                            let mut v1017 = C::inst_data_value_tupled_etor_returns::default();
                            C::inst_data_value_tupled_etor(ctx, v33, &mut v1017);
                            let mut v1017 = v1017.into_context_iter();
                            while let Some(v1018) = v1017.next(ctx) {
                                let v1019 = C::iconst_sextend_etor(ctx, v1018);
                                if let Some(v1020) = v1019 {
                                    let v1023 = constructor_iconst_s(ctx, v335, v1020.1);
                                    let v1024 = C::subsume(ctx, v1023);
                                    // Rule at src/opts/cprop.isle line 131.
                                    returns.extend(Some(v1024));
                                    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 v1869 = C::lane_type(ctx, v2.0);
                                            let v2002 = constructor_fcvt_from_uint(ctx, v1869, v46);
                                            let v2003 = constructor_splat(ctx, v2.0, v2002);
                                            // Rule at src/opts/vector.isle line 6.
                                            returns.extend(Some(v2003));
                                            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 v953,
                                    imm: v954,
                                } => {
                                    if let &Opcode::Iconst = v953 {
                                        match v2.0 {
                                            F32 => {
                                                let v1011 = C::u64_from_imm64(ctx, v954);
                                                let v1163 = C::f32_from_uint(ctx, v1011);
                                                let v1164 = constructor_f32const(ctx, F32, v1163);
                                                // Rule at src/opts/cprop.isle line 355.
                                                returns.extend(Some(v1164));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            F64 => {
                                                let v1011 = C::u64_from_imm64(ctx, v954);
                                                let v1166 = C::f64_from_uint(ctx, v1011);
                                                let v1167 = constructor_f64const(ctx, F64, v1166);
                                                // Rule at src/opts/cprop.isle line 357.
                                                returns.extend(Some(v1167));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            _ => {}
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                    }
                    &Opcode::FcvtFromSint => {
                        match v2.0 {
                            F32 => {
                                let mut v1017 = C::inst_data_value_tupled_etor_returns::default();
                                C::inst_data_value_tupled_etor(ctx, v33, &mut v1017);
                                let mut v1017 = v1017.into_context_iter();
                                while let Some(v1018) = v1017.next(ctx) {
                                    let v1019 = C::iconst_sextend_etor(ctx, v1018);
                                    if let Some(v1020) = v1019 {
                                        let v1168 = C::f32_from_sint(ctx, v1020.1);
                                        let v1169 = constructor_f32const(ctx, F32, v1168);
                                        // Rule at src/opts/cprop.isle line 359.
                                        returns.extend(Some(v1169));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                            }
                            F64 => {
                                let mut v1017 = C::inst_data_value_tupled_etor_returns::default();
                                C::inst_data_value_tupled_etor(ctx, v33, &mut v1017);
                                let mut v1017 = v1017.into_context_iter();
                                while let Some(v1018) = v1017.next(ctx) {
                                    let v1019 = C::iconst_sextend_etor(ctx, v1018);
                                    if let Some(v1020) = v1019 {
                                        let v1170 = C::f64_from_sint(ctx, v1020.1);
                                        let v1171 = constructor_f64const(ctx, F64, v1170);
                                        // Rule at src/opts/cprop.isle line 361.
                                        returns.extend(Some(v1171));
                                        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 v1869 = C::lane_type(ctx, v2.0);
                                        let v2004 = constructor_fcvt_from_sint(ctx, v1869, v46);
                                        let v2005 = constructor_splat(ctx, v2.0, v2004);
                                        // Rule at src/opts/vector.isle line 8.
                                        returns.extend(Some(v2005));
                                        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 v1628,
                imm: v1629,
            } => {
                if let &Opcode::F32const = v1628 {
                    let v1625 = C::remat(ctx, arg0);
                    // Rule at src/opts/remat.isle line 27.
                    returns.extend(Some(v1625));
                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                }
            }
            &InstructionData::UnaryIeee64 {
                opcode: ref v1630,
                imm: v1631,
            } => {
                if let &Opcode::F64const = v1630 {
                    let v1625 = C::remat(ctx, arg0);
                    // Rule at src/opts/remat.isle line 29.
                    returns.extend(Some(v1625));
                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                }
            }
            &InstructionData::UnaryImm {
                opcode: ref v1626,
                imm: v1627,
            } => {
                if let &Opcode::Iconst = v1626 {
                    let v1625 = C::remat(ctx, arg0);
                    // Rule at src/opts/remat.isle line 25.
                    returns.extend(Some(v1625));
                    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 129.
    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 133.
    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 137.
    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 140.
    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 143.
    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 147.
    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 201.
        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 200.
        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 194.
                return v12;
            }
        }
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "iconst_s", "src/prelude_opt.isle line 192")
}

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

// 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 239.
        return arg1;
    }
    let v2 = constructor_uextend(ctx, arg0, arg1);
    // Rule at src/prelude_opt.isle line 238.
    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 245.
        return arg1;
    }
    let v2 = constructor_sextend(ctx, arg0, arg1);
    // Rule at src/prelude_opt.isle line 244.
    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 282.
    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 286.
        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 289.
        return v3;
    }
    let v5 = false;
    // Rule at src/prelude_opt.isle line 292.
    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 321.
    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 326.
        return v11;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "apply_div_const_magic_u32_inner", "src/prelude_opt.isle line 325")
}

// 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 351.
                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 342.
                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 341")
}

// 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 365.
            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 371.
                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 364")
}

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

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

// 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 428.
                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 419.
                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 418")
}

// 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 442.
            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 448.
                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 441")
}

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

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

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

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

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

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

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

// 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 all_zero.
pub fn constructor_all_zero<C: Context>(
    ctx: &mut C,
    arg0: Type,
) -> Value {
    let v16 = C::ty_vec128(ctx, arg0);
    if let Some(v17) = v16 {
        let v18 = C::lane_type(ctx, v17);
        let v19 = constructor_all_zero(ctx, v18);
        let v20 = constructor_splat(ctx, v17, v19);
        // Rule at src/opts/bitops.isle line 22.
        return v20;
    }
    let v11 = C::ty_vec64(ctx, arg0);
    if let Some(v12) = v11 {
        let v13 = C::lane_type(ctx, v12);
        let v14 = constructor_all_zero(ctx, v13);
        let v15 = constructor_splat(ctx, v12, v14);
        // Rule at src/opts/bitops.isle line 21.
        return v15;
    }
    match arg0 {
        F32 => {
            let v6 = C::f32_from_uint(ctx, 0x0_u64);
            let v7 = constructor_f32const(ctx, F32, v6);
            // Rule at src/opts/bitops.isle line 19.
            return v7;
        }
        F64 => {
            let v9 = C::f64_from_uint(ctx, 0x0_u64);
            let v10 = constructor_f64const(ctx, F64, v9);
            // Rule at src/opts/bitops.isle line 20.
            return v10;
        }
        _ => {}
    }
    let v1 = C::ty_int(ctx, arg0);
    if let Some(v2) = v1 {
        let v4 = constructor_iconst_u(ctx, v2, 0x0_u64);
        // Rule at src/opts/bitops.isle line 18.
        return v4;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "all_zero", "src/opts/bitops.isle line 17")
}

// 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 111.
                        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 112.
                        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 115.
                                        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 113.
                                                        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 107.
                        returns.extend(Some(v6));
                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                    }
                    &Opcode::Bitrev => {
                        // Rule at src/opts/bitops.isle line 109.
                        returns.extend(Some(v6));
                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                    }
                    &Opcode::Bswap => {
                        // Rule at src/opts/bitops.isle line 108.
                        returns.extend(Some(v6));
                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                    }
                    &Opcode::Popcnt => {
                        // Rule at src/opts/bitops.isle line 110.
                        returns.extend(Some(v6));
                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                    }
                    &Opcode::Bmask => {
                        // Rule at src/opts/bitops.isle line 106.
                        returns.extend(Some(v6));
                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                    }
                    &Opcode::Uextend => {
                        // Rule at src/opts/bitops.isle line 105.
                        returns.extend(Some(v6));
                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                    }
                    &Opcode::Sextend => {
                        // Rule at src/opts/bitops.isle line 104.
                        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;
}
