// 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/spaceship.isle
// - src/opts/spectre.isle
// - src/opts/vector.isle
// - /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle

use super::*;  // Pulls in all external types.
use std::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 value_type(&mut self, arg0: Value) -> Type;
    fn u32_nonnegative(&mut self, arg0: u32) -> Option<u32>;
    fn offset32(&mut self, arg0: Offset32) -> i32;
    fn u32_lteq(&mut self, arg0: u32, arg1: u32) -> Option<Unit>;
    fn u8_lteq(&mut self, arg0: u8, arg1: u8) -> Option<Unit>;
    fn u8_lt(&mut self, arg0: u8, arg1: u8) -> Option<Unit>;
    fn u8_as_i8(&mut self, arg0: u8) -> i8;
    fn u8_as_u32(&mut self, arg0: u8) -> u32;
    fn u8_as_u64(&mut self, arg0: u8) -> u64;
    fn u16_as_i16(&mut self, arg0: u16) -> i16;
    fn u16_as_u32(&mut self, arg0: u16) -> u32;
    fn u16_as_u64(&mut self, arg0: u16) -> u64;
    fn u64_as_u8(&mut self, arg0: u64) -> u8;
    fn u64_as_u16(&mut self, arg0: u64) -> u16;
    fn u64_as_i64(&mut self, arg0: u64) -> i64;
    fn u8_try_from_u64(&mut self, arg0: u64) -> Option<u8>;
    fn u8_try_from_i32(&mut self, arg0: i32) -> Option<u8>;
    fn u16_try_from_u64(&mut self, arg0: u64) -> Option<u16>;
    fn u32_try_from_u64(&mut self, arg0: u64) -> Option<u32>;
    fn u64_try_from_i64(&mut self, arg0: i64) -> Option<u64>;
    fn i8_try_from_u64(&mut self, arg0: u64) -> Option<i8>;
    fn i16_try_from_u64(&mut self, arg0: u64) -> Option<i16>;
    fn i32_try_from_u64(&mut self, arg0: u64) -> Option<i32>;
    fn u32_as_u64(&mut self, arg0: u32) -> u64;
    fn i32_as_i64(&mut self, arg0: i32) -> i64;
    fn i64_as_u64(&mut self, arg0: i64) -> u64;
    fn i64_neg(&mut self, arg0: i64) -> i64;
    fn i8_neg(&mut self, arg0: i8) -> i8;
    fn u128_as_u64(&mut self, arg0: u128) -> Option<u64>;
    fn u64_as_u32(&mut self, arg0: u64) -> Option<u32>;
    fn u32_as_u16(&mut self, arg0: u32) -> Option<u16>;
    fn i32_as_i8(&mut self, arg0: i32) -> Option<i8>;
    fn u64_as_i32(&mut self, arg0: u64) -> i32;
    fn u8_and(&mut self, arg0: u8, arg1: u8) -> u8;
    fn u8_shl(&mut self, arg0: u8, arg1: u8) -> u8;
    fn u8_shr(&mut self, arg0: u8, arg1: u8) -> u8;
    fn u8_sub(&mut self, arg0: u8, arg1: u8) -> u8;
    fn u32_add(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_sub(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_and(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_shl(&mut self, arg0: u32, arg1: u32) -> u32;
    fn s32_add_fallible(&mut self, arg0: i32, arg1: i32) -> Option<i32>;
    fn u64_add(&mut self, arg0: u64, arg1: u64) -> u64;
    fn u64_sub(&mut self, arg0: u64, arg1: u64) -> u64;
    fn u64_mul(&mut self, arg0: u64, arg1: u64) -> u64;
    fn u64_sdiv(&mut self, arg0: u64, arg1: u64) -> Option<u64>;
    fn u64_udiv(&mut self, arg0: u64, arg1: u64) -> Option<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_shl(&mut self, arg0: u64, arg1: u64) -> u64;
    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 u64_not(&mut self, arg0: u64) -> u64;
    fn u64_eq(&mut self, arg0: u64, arg1: u64) -> bool;
    fn u64_le(&mut self, arg0: u64, arg1: u64) -> bool;
    fn u64_lt(&mut self, arg0: u64, arg1: u64) -> bool;
    fn i64_shr(&mut self, arg0: i64, arg1: i64) -> i64;
    fn i64_ctz(&mut self, arg0: i64) -> i64;
    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 u64_is_zero(&mut self, arg0: u64) -> bool;
    fn i64_is_zero(&mut self, arg0: i64) -> bool;
    fn u64_is_odd(&mut self, arg0: u64) -> bool;
    fn u128_replicated_u64(&mut self, arg0: u128) -> Option<u64>;
    fn u64_replicated_u32(&mut self, arg0: u64) -> Option<u64>;
    fn u32_replicated_u16(&mut self, arg0: u64) -> Option<u64>;
    fn u16_replicated_u8(&mut self, arg0: u64) -> Option<u8>;
    fn 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 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_32(&mut self, arg0: Type) -> Option<Type>;
    fn ty_64(&mut self, arg0: Type) -> Option<Type>;
    fn ty_int_ref_scalar_64_extract(&mut self, arg0: Type) -> Option<Type>;
    fn ty_int_ref_scalar_64(&mut self, arg0: Type) -> Option<Type>;
    fn ty_32_or_64(&mut self, arg0: Type) -> Option<Type>;
    fn ty_8_or_16(&mut self, arg0: Type) -> Option<Type>;
    fn ty_16_or_32(&mut self, arg0: Type) -> Option<Type>;
    fn int_fits_in_32(&mut self, arg0: Type) -> Option<Type>;
    fn ty_int_ref_64(&mut self, arg0: Type) -> Option<Type>;
    fn ty_int_ref_16_to_64(&mut self, arg0: Type) -> Option<Type>;
    fn ty_int(&mut self, arg0: Type) -> Option<Type>;
    fn ty_scalar(&mut self, arg0: Type) -> Option<Type>;
    fn ty_scalar_float(&mut self, arg0: Type) -> Option<Type>;
    fn ty_float_or_vec(&mut self, arg0: Type) -> Option<Type>;
    fn ty_vector_float(&mut self, arg0: Type) -> Option<Type>;
    fn ty_vector_not_float(&mut self, arg0: Type) -> Option<Type>;
    fn ty_vec64(&mut self, arg0: Type) -> Option<Type>;
    fn ty_vec64_ctor(&mut self, arg0: Type) -> Option<Type>;
    fn ty_vec128(&mut self, arg0: Type) -> Option<Type>;
    fn ty_dyn_vec64(&mut self, arg0: Type) -> Option<Type>;
    fn ty_dyn_vec128(&mut self, arg0: Type) -> Option<Type>;
    fn ty_vec64_int(&mut self, arg0: Type) -> Option<Type>;
    fn ty_vec128_int(&mut self, arg0: Type) -> Option<Type>;
    fn ty_addr64(&mut self, arg0: Type) -> Option<Type>;
    fn not_vec32x2(&mut self, arg0: Type) -> Option<Type>;
    fn not_i64x2(&mut self, arg0: Type) -> Option<()>;
    fn u8_from_uimm8(&mut self, arg0: Uimm8) -> u8;
    fn u64_from_bool(&mut self, arg0: bool) -> u64;
    fn u64_from_imm64(&mut self, arg0: Imm64) -> u64;
    fn nonzero_u64_from_imm64(&mut self, arg0: Imm64) -> Option<u64>;
    fn imm64_power_of_two(&mut self, arg0: Imm64) -> Option<u64>;
    fn imm64(&mut self, arg0: u64) -> Imm64;
    fn imm64_masked(&mut self, arg0: Type, arg1: u64) -> Imm64;
    fn u16_from_ieee16(&mut self, arg0: Ieee16) -> u16;
    fn u32_from_ieee32(&mut self, arg0: Ieee32) -> u32;
    fn u64_from_ieee64(&mut self, arg0: Ieee64) -> u64;
    fn multi_lane(&mut self, arg0: Type) -> Option<(u32, u32)>;
    fn dynamic_lane(&mut self, arg0: Type) -> Option<(u32, u32)>;
    fn ty_dyn64_int(&mut self, arg0: Type) -> Option<Type>;
    fn ty_dyn128_int(&mut self, arg0: Type) -> Option<Type>;
    fn offset32_to_i32(&mut self, arg0: Offset32) -> i32;
    fn i32_to_offset32(&mut self, arg0: i32) -> Offset32;
    fn intcc_unsigned(&mut self, arg0: &IntCC) -> IntCC;
    fn signed_cond_code(&mut self, arg0: &IntCC) -> Option<IntCC>;
    fn trap_code_division_by_zero(&mut self, ) -> TrapCode;
    fn trap_code_integer_overflow(&mut self, ) -> TrapCode;
    fn trap_code_bad_conversion_to_integer(&mut self, ) -> TrapCode;
    fn range(&mut self, arg0: usize, arg1: usize) -> Range;
    fn range_view(&mut self, arg0: Range) -> RangeView;
    type inst_data_etor_returns: Default + IntoContextIter<Context = Self, Output = (Type, InstructionData)>;
    fn inst_data_etor(&mut self, arg0: Value, returns: &mut Self::inst_data_etor_returns) -> ();
    type inst_data_tupled_etor_returns: Default + IntoContextIter<Context = Self, Output = TypeAndInstructionData>;
    fn inst_data_tupled_etor(&mut self, arg0: Value, returns: &mut Self::inst_data_tupled_etor_returns) -> ();
    fn make_inst_ctor(&mut self, arg0: Type, arg1: &InstructionData) -> Value;
    fn value_array_2_ctor(&mut self, arg0: Value, arg1: Value) -> ValueArray2;
    fn value_array_3_ctor(&mut self, arg0: Value, arg1: Value, arg2: Value) -> ValueArray3;
    fn remat(&mut self, arg0: Value) -> Value;
    fn subsume(&mut self, arg0: Value) -> Value;
    fn iconst_sextend_etor(&mut self, arg0: TypeAndInstructionData) -> Option<(Type, i64)>;
    type sextend_maybe_etor_returns: Default + IntoContextIter<Context = Self, Output = (Type, Value)>;
    fn sextend_maybe_etor(&mut self, arg0: Value, returns: &mut Self::sextend_maybe_etor_returns) -> ();
    type uextend_maybe_etor_returns: Default + IntoContextIter<Context = Self, Output = (Type, Value)>;
    fn uextend_maybe_etor(&mut self, arg0: Value, returns: &mut Self::uextend_maybe_etor_returns) -> ();
    fn splat64(&mut self, arg0: u64) -> Constant;
    fn f32_from_uint(&mut self, arg0: u64) -> Ieee32;
    fn f64_from_uint(&mut self, arg0: u64) -> Ieee64;
    fn f32_from_sint(&mut self, arg0: i64) -> Ieee32;
    fn f64_from_sint(&mut self, arg0: i64) -> Ieee64;
    fn u64_bswap16(&mut self, arg0: u64) -> u64;
    fn u64_bswap32(&mut self, arg0: u64) -> u64;
    fn u64_bswap64(&mut self, arg0: u64) -> u64;
    fn ieee128_constant_extractor(&mut self, arg0: Constant) -> Option<Ieee128>;
    fn ieee128_constant(&mut self, arg0: Ieee128) -> Constant;
    fn 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 std::vec::Vec<T> {
    fn len(&self) -> usize {
        std::vec::Vec::len(self)
    }
}

pub struct ContextIterWrapper<I, C> {
    iter: I,
    _ctx: std::marker::PhantomData<C>,
}
impl<I: Default, C> Default for ContextIterWrapper<I, C> {
    fn default() -> Self {
        ContextIterWrapper {
            iter: I::default(),
            _ctx: std::marker::PhantomData
        }
    }
}
impl<I, C> std::ops::Deref for ContextIterWrapper<I, C> {
    type Target = I;
    fn deref(&self) -> &I {
        &self.iter
    }
}
impl<I, C> std::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: std::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: std::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()
    }
}
           

// 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_as_u64(ctx, v2);
    let v5 = C::u64_sub(ctx, v3, 0x1_u64);
    // Rule at src/prelude.isle line 473.
    return v5;
}

// 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 29.
    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 30.
    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 31.
    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 32.
    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 33.
    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 34.
    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 35.
    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 36.
    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 37.
    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 38.
    return v4;
}

// 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 42.
    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 45.
    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_etor_returns::default();
    C::inst_data_etor(ctx, arg0, &mut v1);
    let mut v1 = v1.into_context_iter();
    while let Some(v2) = v1.next(ctx) {
        match &v2.1 {
            &InstructionData::Binary {
                opcode: ref v5,
                args: ref v6,
            } => {
                match v5 {
                    &Opcode::Smin => {
                        let v7 = C::unpack_value_array_2(ctx, v6);
                        let mut v10 = C::inst_data_etor_returns::default();
                        C::inst_data_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_etor_returns::default();
                                        C::inst_data_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 v1186 = C::lane_type(ctx, v2.0);
                                                        let v1339 = constructor_smin(ctx, v1186, v30, v27);
                                                        let v1340 = constructor_splat(ctx, v2.0, v1339);
                                                        // Rule at src/opts/vector.isle line 54.
                                                        returns.extend(Some(v1340));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    &Opcode::Umin => {
                        let v7 = C::unpack_value_array_2(ctx, v6);
                        let mut v10 = C::inst_data_etor_returns::default();
                        C::inst_data_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_etor_returns::default();
                                        C::inst_data_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 v1186 = C::lane_type(ctx, v2.0);
                                                        let v1341 = constructor_umin(ctx, v1186, v30, v27);
                                                        let v1342 = constructor_splat(ctx, v2.0, v1341);
                                                        // Rule at src/opts/vector.isle line 57.
                                                        returns.extend(Some(v1342));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    &Opcode::Smax => {
                        let v7 = C::unpack_value_array_2(ctx, v6);
                        let mut v10 = C::inst_data_etor_returns::default();
                        C::inst_data_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_etor_returns::default();
                                        C::inst_data_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 v1186 = C::lane_type(ctx, v2.0);
                                                        let v1343 = constructor_smax(ctx, v1186, v30, v27);
                                                        let v1344 = constructor_splat(ctx, v2.0, v1343);
                                                        // Rule at src/opts/vector.isle line 60.
                                                        returns.extend(Some(v1344));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    &Opcode::Umax => {
                        let v7 = C::unpack_value_array_2(ctx, v6);
                        let mut v10 = C::inst_data_etor_returns::default();
                        C::inst_data_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_etor_returns::default();
                                        C::inst_data_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 v1186 = C::lane_type(ctx, v2.0);
                                                        let v1345 = constructor_umax(ctx, v1186, v30, v27);
                                                        let v1346 = constructor_splat(ctx, v2.0, v1345);
                                                        // Rule at src/opts/vector.isle line 63.
                                                        returns.extend(Some(v1346));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    &Opcode::Iadd => {
                        let v7 = C::unpack_value_array_2(ctx, v6);
                        let mut v10 = C::inst_data_etor_returns::default();
                        C::inst_data_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 v104,
                                    args: ref v105,
                                } => {
                                    match v104 {
                                        &Opcode::Iadd => {
                                            if v2.0 == v11.0 {
                                                let v106 = C::unpack_value_array_2(ctx, v105);
                                                let mut v109 = C::inst_data_etor_returns::default();
                                                C::inst_data_etor(ctx, v106.1, &mut v109);
                                                let mut v109 = v109.into_context_iter();
                                                while let Some(v110) = v109.next(ctx) {
                                                    match &v110.1 {
                                                        &InstructionData::Binary {
                                                            opcode: ref v113,
                                                            args: ref v114,
                                                        } => {
                                                            match v113 {
                                                                &Opcode::Iadd => {
                                                                    if v2.0 == v110.0 {
                                                                        let v118 = constructor_iadd(ctx, v2.0, v7.0, v106.0);
                                                                        let v115 = C::unpack_value_array_2(ctx, v114);
                                                                        let v119 = constructor_iadd(ctx, v2.0, v115.0, v115.1);
                                                                        let v120 = constructor_iadd(ctx, v2.0, v118, v119);
                                                                        let v121 = C::subsume(ctx, v120);
                                                                        // Rule at src/opts/arithmetic.isle line 134.
                                                                        returns.extend(Some(v121));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                                &Opcode::Isub => {
                                                                    if v2.0 == v110.0 {
                                                                        let v118 = constructor_iadd(ctx, v2.0, v7.0, v106.0);
                                                                        let v115 = C::unpack_value_array_2(ctx, v114);
                                                                        let v165 = constructor_isub(ctx, v2.0, v115.0, v115.1);
                                                                        let v178 = constructor_iadd(ctx, v2.0, v118, v165);
                                                                        let v179 = C::subsume(ctx, v178);
                                                                        // Rule at src/opts/arithmetic.isle line 182.
                                                                        returns.extend(Some(v179));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                        &InstructionData::UnaryImm {
                                                            opcode: ref v686,
                                                            imm: v687,
                                                        } => {
                                                            if let &Opcode::Iconst = v686 {
                                                                let mut v18 = C::inst_data_etor_returns::default();
                                                                C::inst_data_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 v122,
                                                                        args: ref v123,
                                                                    } = &v19.1 {
                                                                        if let &Opcode::Iadd = v122 {
                                                                            if v2.0 == v19.0 {
                                                                                let v124 = C::unpack_value_array_2(ctx, v123);
                                                                                let mut v199 = C::inst_data_etor_returns::default();
                                                                                C::inst_data_etor(ctx, v124.1, &mut v199);
                                                                                let mut v199 = v199.into_context_iter();
                                                                                while let Some(v200) = v199.next(ctx) {
                                                                                    if let &InstructionData::UnaryImm {
                                                                                        opcode: ref v226,
                                                                                        imm: v227,
                                                                                    } = &v200.1 {
                                                                                        if let &Opcode::Iconst = v226 {
                                                                                            let v688 = constructor_iadd(ctx, v2.0, v124.0, v106.0);
                                                                                            let v689 = constructor_iadd(ctx, v2.0, v124.1, v106.1);
                                                                                            let v690 = constructor_iadd(ctx, v2.0, v688, v689);
                                                                                            // Rule at src/opts/cprop.isle line 224.
                                                                                            returns.extend(Some(v690));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Isub => {
                                            if v2.0 == v11.0 {
                                                let v106 = C::unpack_value_array_2(ctx, v105);
                                                let mut v109 = C::inst_data_etor_returns::default();
                                                C::inst_data_etor(ctx, v106.1, &mut v109);
                                                let mut v109 = v109.into_context_iter();
                                                while let Some(v110) = v109.next(ctx) {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v113,
                                                        args: ref v114,
                                                    } = &v110.1 {
                                                        match v113 {
                                                            &Opcode::Iadd => {
                                                                if v2.0 == v110.0 {
                                                                    let v118 = constructor_iadd(ctx, v2.0, v7.0, v106.0);
                                                                    let v115 = C::unpack_value_array_2(ctx, v114);
                                                                    let v119 = constructor_iadd(ctx, v2.0, v115.0, v115.1);
                                                                    let v176 = constructor_isub(ctx, v2.0, v118, v119);
                                                                    let v177 = C::subsume(ctx, v176);
                                                                    // Rule at src/opts/arithmetic.isle line 178.
                                                                    returns.extend(Some(v177));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                            &Opcode::Isub => {
                                                                if v2.0 == v110.0 {
                                                                    let v118 = constructor_iadd(ctx, v2.0, v7.0, v106.0);
                                                                    let v115 = C::unpack_value_array_2(ctx, v114);
                                                                    let v165 = constructor_isub(ctx, v2.0, v115.0, v115.1);
                                                                    let v174 = constructor_isub(ctx, v2.0, v118, v165);
                                                                    let v175 = C::subsume(ctx, v174);
                                                                    // Rule at src/opts/arithmetic.isle line 174.
                                                                    returns.extend(Some(v175));
                                                                    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_etor_returns::default();
                                                C::inst_data_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 v1186 = C::lane_type(ctx, v2.0);
                                                                let v1323 = constructor_iadd(ctx, v1186, v30, v27);
                                                                let v1324 = constructor_splat(ctx, v2.0, v1323);
                                                                // Rule at src/opts/vector.isle line 30.
                                                                returns.extend(Some(v1324));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Ineg => {
                                            if v2.0 == v11.0 {
                                                let v28 = constructor_isub(ctx, v2.0, v7.0, v27);
                                                // Rule at src/opts/arithmetic.isle line 23.
                                                returns.extend(Some(v28));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v14,
                                    imm: v15,
                                } => {
                                    if let &Opcode::Iconst = v14 {
                                        if v2.0 == v11.0 {
                                            let mut v18 = C::inst_data_etor_returns::default();
                                            C::inst_data_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 v122,
                                                        args: ref v123,
                                                    } => {
                                                        match v122 {
                                                            &Opcode::Iadd => {
                                                                if v2.0 == v19.0 {
                                                                    let v124 = C::unpack_value_array_2(ctx, v123);
                                                                    let mut v199 = C::inst_data_etor_returns::default();
                                                                    C::inst_data_etor(ctx, v124.1, &mut v199);
                                                                    let mut v199 = v199.into_context_iter();
                                                                    while let Some(v200) = v199.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v226,
                                                                            imm: v227,
                                                                        } = &v200.1 {
                                                                            if let &Opcode::Iconst = v226 {
                                                                                if v2.0 == v200.0 {
                                                                                    let v611 = constructor_iadd(ctx, v2.0, v124.1, v7.1);
                                                                                    let v612 = constructor_iadd(ctx, v2.0, v124.0, v611);
                                                                                    // Rule at src/opts/cprop.isle line 125.
                                                                                    returns.extend(Some(v612));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Isub => {
                                                                if v2.0 == v19.0 {
                                                                    let v124 = C::unpack_value_array_2(ctx, v123);
                                                                    let mut v127 = C::inst_data_etor_returns::default();
                                                                    C::inst_data_etor(ctx, v124.0, &mut v127);
                                                                    let mut v127 = v127.into_context_iter();
                                                                    while let Some(v128) = v127.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v617,
                                                                            imm: v618,
                                                                        } = &v128.1 {
                                                                            if let &Opcode::Iconst = v617 {
                                                                                if v2.0 == v128.0 {
                                                                                    let v619 = C::u64_from_imm64(ctx, v618);
                                                                                    let v16 = C::u64_from_imm64(ctx, v15);
                                                                                    let v629 = C::u64_add(ctx, v619, v16);
                                                                                    let v630 = C::imm64_masked(ctx, v2.0, v629);
                                                                                    let v631 = constructor_iconst(ctx, v2.0, v630);
                                                                                    let v632 = constructor_isub(ctx, v2.0, v631, v124.1);
                                                                                    // Rule at src/opts/cprop.isle line 151.
                                                                                    returns.extend(Some(v632));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    let mut v199 = C::inst_data_etor_returns::default();
                                                                    C::inst_data_etor(ctx, v124.1, &mut v199);
                                                                    let mut v199 = v199.into_context_iter();
                                                                    while let Some(v200) = v199.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v226,
                                                                            imm: v227,
                                                                        } = &v200.1 {
                                                                            if let &Opcode::Iconst = v226 {
                                                                                if v2.0 == v200.0 {
                                                                                    let v16 = C::u64_from_imm64(ctx, v15);
                                                                                    let v228 = C::u64_from_imm64(ctx, v227);
                                                                                    let v624 = C::u64_sub(ctx, v16, v228);
                                                                                    let v625 = C::imm64_masked(ctx, v2.0, v624);
                                                                                    let v626 = constructor_iconst(ctx, v2.0, v625);
                                                                                    let v628 = constructor_iadd(ctx, v2.0, v124.0, v626);
                                                                                    // Rule at src/opts/cprop.isle line 147.
                                                                                    returns.extend(Some(v628));
                                                                                    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 v65 = constructor_ineg(ctx, v2.0, v30);
                                                                    // Rule at src/opts/arithmetic.isle line 68.
                                                                    returns.extend(Some(v65));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                    _ => {}
                                                }
                                            }
                                            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 v526 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v527) = v526 {
                                            if v11.0 == v527 {
                                                let mut v18 = C::inst_data_etor_returns::default();
                                                C::inst_data_etor(ctx, v7.0, &mut v18);
                                                let mut v18 = v18.into_context_iter();
                                                while let Some(v19) = v18.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v22,
                                                        imm: v23,
                                                    } = &v19.1 {
                                                        if let &Opcode::Iconst = v22 {
                                                            if v11.0 == v19.0 {
                                                                let v24 = C::u64_from_imm64(ctx, v23);
                                                                let v16 = C::u64_from_imm64(ctx, v15);
                                                                let v528 = C::u64_add(ctx, v24, v16);
                                                                let v529 = C::imm64_masked(ctx, v527, v528);
                                                                let v530 = constructor_iconst(ctx, v527, v529);
                                                                let v531 = C::subsume(ctx, v530);
                                                                // Rule at src/opts/cprop.isle line 2.
                                                                returns.extend(Some(v531));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        let v1077 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 5.
                                        returns.extend(Some(v1077));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                _ => {}
                            }
                        }
                        let mut v18 = C::inst_data_etor_returns::default();
                        C::inst_data_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 v122,
                                    args: ref v123,
                                } => {
                                    match v122 {
                                        &Opcode::Iadd => {
                                            if v2.0 == v19.0 {
                                                let v124 = C::unpack_value_array_2(ctx, v123);
                                                let mut v127 = C::inst_data_etor_returns::default();
                                                C::inst_data_etor(ctx, v124.0, &mut v127);
                                                let mut v127 = v127.into_context_iter();
                                                while let Some(v128) = v127.next(ctx) {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v131,
                                                        args: ref v132,
                                                    } = &v128.1 {
                                                        match v131 {
                                                            &Opcode::Iadd => {
                                                                if v2.0 == v128.0 {
                                                                    let v133 = C::unpack_value_array_2(ctx, v132);
                                                                    let v136 = constructor_iadd(ctx, v2.0, v133.0, v133.1);
                                                                    let v137 = constructor_iadd(ctx, v2.0, v124.1, v7.1);
                                                                    let v138 = constructor_iadd(ctx, v2.0, v136, v137);
                                                                    let v139 = C::subsume(ctx, v138);
                                                                    // Rule at src/opts/arithmetic.isle line 136.
                                                                    returns.extend(Some(v139));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                            &Opcode::Isub => {
                                                                if v2.0 == v128.0 {
                                                                    let v133 = C::unpack_value_array_2(ctx, v132);
                                                                    let v180 = constructor_isub(ctx, v2.0, v133.0, v133.1);
                                                                    let v137 = constructor_iadd(ctx, v2.0, v124.1, v7.1);
                                                                    let v188 = constructor_iadd(ctx, v2.0, v180, v137);
                                                                    let v189 = C::subsume(ctx, v188);
                                                                    // Rule at src/opts/arithmetic.isle line 200.
                                                                    returns.extend(Some(v189));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Isub => {
                                            if v2.0 == v19.0 {
                                                let v124 = C::unpack_value_array_2(ctx, v123);
                                                let mut v127 = C::inst_data_etor_returns::default();
                                                C::inst_data_etor(ctx, v124.0, &mut v127);
                                                let mut v127 = v127.into_context_iter();
                                                while let Some(v128) = v127.next(ctx) {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v131,
                                                        args: ref v132,
                                                    } = &v128.1 {
                                                        match v131 {
                                                            &Opcode::Iadd => {
                                                                if v2.0 == v128.0 {
                                                                    let v133 = C::unpack_value_array_2(ctx, v132);
                                                                    let v136 = constructor_iadd(ctx, v2.0, v133.0, v133.1);
                                                                    let v183 = constructor_isub(ctx, v2.0, v124.1, v7.1);
                                                                    let v192 = constructor_isub(ctx, v2.0, v136, v183);
                                                                    let v193 = C::subsume(ctx, v192);
                                                                    // Rule at src/opts/arithmetic.isle line 208.
                                                                    returns.extend(Some(v193));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                            &Opcode::Isub => {
                                                                if v2.0 == v128.0 {
                                                                    let v133 = C::unpack_value_array_2(ctx, v132);
                                                                    let v180 = constructor_isub(ctx, v2.0, v133.0, v133.1);
                                                                    let v183 = constructor_isub(ctx, v2.0, v124.1, v7.1);
                                                                    let v184 = constructor_isub(ctx, v2.0, v180, v183);
                                                                    let v185 = C::subsume(ctx, v184);
                                                                    // Rule at src/opts/arithmetic.isle line 192.
                                                                    returns.extend(Some(v185));
                                                                    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 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; }
                                        }
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v22,
                                    imm: v23,
                                } => {
                                    if let &Opcode::Iconst = v22 {
                                        if v2.0 == v19.0 {
                                            let v602 = constructor_iadd(ctx, v2.0, v7.1, v7.0);
                                            // Rule at src/opts/cprop.isle line 94.
                                            returns.extend(Some(v602));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        let v1077 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 3.
                                        returns.extend(Some(v1077));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                _ => {}
                            }
                        }
                    }
                    &Opcode::Isub => {
                        let v7 = C::unpack_value_array_2(ctx, v6);
                        let mut v10 = C::inst_data_etor_returns::default();
                        C::inst_data_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 v104,
                                    args: ref v105,
                                } => {
                                    match v104 {
                                        &Opcode::Iadd => {
                                            if v2.0 == v11.0 {
                                                let v106 = C::unpack_value_array_2(ctx, v105);
                                                let mut v109 = C::inst_data_etor_returns::default();
                                                C::inst_data_etor(ctx, v106.1, &mut v109);
                                                let mut v109 = v109.into_context_iter();
                                                while let Some(v110) = v109.next(ctx) {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v113,
                                                        args: ref v114,
                                                    } = &v110.1 {
                                                        match v113 {
                                                            &Opcode::Iadd => {
                                                                if v2.0 == v110.0 {
                                                                    let v164 = constructor_isub(ctx, v2.0, v7.0, v106.0);
                                                                    let v115 = C::unpack_value_array_2(ctx, v114);
                                                                    let v119 = constructor_iadd(ctx, v2.0, v115.0, v115.1);
                                                                    let v172 = constructor_isub(ctx, v2.0, v164, v119);
                                                                    let v173 = C::subsume(ctx, v172);
                                                                    // Rule at src/opts/arithmetic.isle line 170.
                                                                    returns.extend(Some(v173));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                            &Opcode::Isub => {
                                                                if v2.0 == v110.0 {
                                                                    let v164 = constructor_isub(ctx, v2.0, v7.0, v106.0);
                                                                    let v115 = C::unpack_value_array_2(ctx, v114);
                                                                    let v165 = constructor_isub(ctx, v2.0, v115.0, v115.1);
                                                                    let v170 = constructor_isub(ctx, v2.0, v164, v165);
                                                                    let v171 = C::subsume(ctx, v170);
                                                                    // Rule at src/opts/arithmetic.isle line 166.
                                                                    returns.extend(Some(v171));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Isub => {
                                            if v2.0 == v11.0 {
                                                let v106 = C::unpack_value_array_2(ctx, v105);
                                                let mut v109 = C::inst_data_etor_returns::default();
                                                C::inst_data_etor(ctx, v106.1, &mut v109);
                                                let mut v109 = v109.into_context_iter();
                                                while let Some(v110) = v109.next(ctx) {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v113,
                                                        args: ref v114,
                                                    } = &v110.1 {
                                                        match v113 {
                                                            &Opcode::Iadd => {
                                                                if v2.0 == v110.0 {
                                                                    let v164 = constructor_isub(ctx, v2.0, v7.0, v106.0);
                                                                    let v115 = C::unpack_value_array_2(ctx, v114);
                                                                    let v119 = constructor_iadd(ctx, v2.0, v115.0, v115.1);
                                                                    let v168 = constructor_iadd(ctx, v2.0, v164, v119);
                                                                    let v169 = C::subsume(ctx, v168);
                                                                    // Rule at src/opts/arithmetic.isle line 162.
                                                                    returns.extend(Some(v169));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                            &Opcode::Isub => {
                                                                if v2.0 == v110.0 {
                                                                    let v164 = constructor_isub(ctx, v2.0, v7.0, v106.0);
                                                                    let v115 = C::unpack_value_array_2(ctx, v114);
                                                                    let v165 = constructor_isub(ctx, v2.0, v115.0, v115.1);
                                                                    let v166 = constructor_iadd(ctx, v2.0, v164, v165);
                                                                    let v167 = C::subsume(ctx, v166);
                                                                    // Rule at src/opts/arithmetic.isle line 158.
                                                                    returns.extend(Some(v167));
                                                                    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_etor_returns::default();
                                                C::inst_data_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 v1186 = C::lane_type(ctx, v2.0);
                                                                let v1325 = constructor_isub(ctx, v1186, v30, v27);
                                                                let v1326 = constructor_splat(ctx, v2.0, v1325);
                                                                // Rule at src/opts/vector.isle line 33.
                                                                returns.extend(Some(v1326));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Ineg => {
                                            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 {
                                        if v2.0 == v11.0 {
                                            let mut v18 = C::inst_data_etor_returns::default();
                                            C::inst_data_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 v122,
                                                    args: ref v123,
                                                } = &v19.1 {
                                                    match v122 {
                                                        &Opcode::Iadd => {
                                                            if v2.0 == v19.0 {
                                                                let v124 = C::unpack_value_array_2(ctx, v123);
                                                                let mut v199 = C::inst_data_etor_returns::default();
                                                                C::inst_data_etor(ctx, v124.1, &mut v199);
                                                                let mut v199 = v199.into_context_iter();
                                                                while let Some(v200) = v199.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v226,
                                                                        imm: v227,
                                                                    } = &v200.1 {
                                                                        if let &Opcode::Iconst = v226 {
                                                                            if v2.0 == v200.0 {
                                                                                let v16 = C::u64_from_imm64(ctx, v15);
                                                                                let v228 = C::u64_from_imm64(ctx, v227);
                                                                                let v624 = C::u64_sub(ctx, v16, v228);
                                                                                let v625 = C::imm64_masked(ctx, v2.0, v624);
                                                                                let v626 = constructor_iconst(ctx, v2.0, v625);
                                                                                let v627 = constructor_isub(ctx, v2.0, v124.0, v626);
                                                                                // Rule at src/opts/cprop.isle line 143.
                                                                                returns.extend(Some(v627));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &Opcode::Isub => {
                                                            if v2.0 == v19.0 {
                                                                let v124 = C::unpack_value_array_2(ctx, v123);
                                                                let mut v127 = C::inst_data_etor_returns::default();
                                                                C::inst_data_etor(ctx, v124.0, &mut v127);
                                                                let mut v127 = v127.into_context_iter();
                                                                while let Some(v128) = v127.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v617,
                                                                        imm: v618,
                                                                    } = &v128.1 {
                                                                        if let &Opcode::Iconst = v617 {
                                                                            if v2.0 == v128.0 {
                                                                                let v619 = C::u64_from_imm64(ctx, v618);
                                                                                let v16 = C::u64_from_imm64(ctx, v15);
                                                                                let v620 = C::u64_sub(ctx, v619, v16);
                                                                                let v621 = C::imm64_masked(ctx, v2.0, v620);
                                                                                let v622 = constructor_iconst(ctx, v2.0, v621);
                                                                                let v623 = constructor_isub(ctx, v2.0, v622, v124.1);
                                                                                // Rule at src/opts/cprop.isle line 139.
                                                                                returns.extend(Some(v623));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                let mut v199 = C::inst_data_etor_returns::default();
                                                                C::inst_data_etor(ctx, v124.1, &mut v199);
                                                                let mut v199 = v199.into_context_iter();
                                                                while let Some(v200) = v199.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v226,
                                                                        imm: v227,
                                                                    } = &v200.1 {
                                                                        if let &Opcode::Iconst = v226 {
                                                                            if v2.0 == v200.0 {
                                                                                let v228 = C::u64_from_imm64(ctx, v227);
                                                                                let v16 = C::u64_from_imm64(ctx, v15);
                                                                                let v613 = C::u64_add(ctx, v228, v16);
                                                                                let v614 = C::imm64_masked(ctx, v2.0, v613);
                                                                                let v615 = constructor_iconst(ctx, v2.0, v614);
                                                                                let v616 = constructor_isub(ctx, v2.0, v124.0, v615);
                                                                                // Rule at src/opts/cprop.isle line 135.
                                                                                returns.extend(Some(v616));
                                                                                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 12.
                                                returns.extend(Some(v17));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        let v526 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v527) = v526 {
                                            if v11.0 == v527 {
                                                let mut v18 = C::inst_data_etor_returns::default();
                                                C::inst_data_etor(ctx, v7.0, &mut v18);
                                                let mut v18 = v18.into_context_iter();
                                                while let Some(v19) = v18.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v22,
                                                        imm: v23,
                                                    } = &v19.1 {
                                                        if let &Opcode::Iconst = v22 {
                                                            if v11.0 == v19.0 {
                                                                let v24 = C::u64_from_imm64(ctx, v23);
                                                                let v16 = C::u64_from_imm64(ctx, v15);
                                                                let v532 = C::u64_sub(ctx, v24, v16);
                                                                let v533 = C::imm64_masked(ctx, v527, v532);
                                                                let v534 = constructor_iconst(ctx, v527, v533);
                                                                let v535 = C::subsume(ctx, v534);
                                                                // Rule at src/opts/cprop.isle line 8.
                                                                returns.extend(Some(v535));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        let v1077 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 9.
                                        returns.extend(Some(v1077));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                _ => {}
                            }
                        }
                        let mut v18 = C::inst_data_etor_returns::default();
                        C::inst_data_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 v122,
                                    args: ref v123,
                                } => {
                                    match v122 {
                                        &Opcode::Iadd => {
                                            if v2.0 == v19.0 {
                                                let v124 = C::unpack_value_array_2(ctx, v123);
                                                let mut v127 = C::inst_data_etor_returns::default();
                                                C::inst_data_etor(ctx, v124.0, &mut v127);
                                                let mut v127 = v127.into_context_iter();
                                                while let Some(v128) = v127.next(ctx) {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v131,
                                                        args: ref v132,
                                                    } = &v128.1 {
                                                        match v131 {
                                                            &Opcode::Iadd => {
                                                                if v2.0 == v128.0 {
                                                                    let v133 = C::unpack_value_array_2(ctx, v132);
                                                                    let v136 = constructor_iadd(ctx, v2.0, v133.0, v133.1);
                                                                    let v183 = constructor_isub(ctx, v2.0, v124.1, v7.1);
                                                                    let v194 = constructor_iadd(ctx, v2.0, v136, v183);
                                                                    let v195 = C::subsume(ctx, v194);
                                                                    // Rule at src/opts/arithmetic.isle line 212.
                                                                    returns.extend(Some(v195));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                            &Opcode::Isub => {
                                                                if v2.0 == v128.0 {
                                                                    let v133 = C::unpack_value_array_2(ctx, v132);
                                                                    let v180 = constructor_isub(ctx, v2.0, v133.0, v133.1);
                                                                    let v183 = constructor_isub(ctx, v2.0, v124.1, v7.1);
                                                                    let v186 = constructor_iadd(ctx, v2.0, v180, v183);
                                                                    let v187 = C::subsume(ctx, v186);
                                                                    // Rule at src/opts/arithmetic.isle line 196.
                                                                    returns.extend(Some(v187));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Isub => {
                                            if v2.0 == v19.0 {
                                                let v124 = C::unpack_value_array_2(ctx, v123);
                                                let mut v127 = C::inst_data_etor_returns::default();
                                                C::inst_data_etor(ctx, v124.0, &mut v127);
                                                let mut v127 = v127.into_context_iter();
                                                while let Some(v128) = v127.next(ctx) {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v131,
                                                        args: ref v132,
                                                    } = &v128.1 {
                                                        match v131 {
                                                            &Opcode::Iadd => {
                                                                if v2.0 == v128.0 {
                                                                    let v133 = C::unpack_value_array_2(ctx, v132);
                                                                    let v136 = constructor_iadd(ctx, v2.0, v133.0, v133.1);
                                                                    let v137 = constructor_iadd(ctx, v2.0, v124.1, v7.1);
                                                                    let v190 = constructor_isub(ctx, v2.0, v136, v137);
                                                                    let v191 = C::subsume(ctx, v190);
                                                                    // Rule at src/opts/arithmetic.isle line 204.
                                                                    returns.extend(Some(v191));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                            &Opcode::Isub => {
                                                                if v2.0 == v128.0 {
                                                                    let v133 = C::unpack_value_array_2(ctx, v132);
                                                                    let v180 = constructor_isub(ctx, v2.0, v133.0, v133.1);
                                                                    let v137 = constructor_iadd(ctx, v2.0, v124.1, v7.1);
                                                                    let v181 = constructor_isub(ctx, v2.0, v180, v137);
                                                                    let v182 = C::subsume(ctx, v181);
                                                                    // Rule at src/opts/arithmetic.isle line 188.
                                                                    returns.extend(Some(v182));
                                                                    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 v603 = constructor_isub(ctx, v2.0, v7.1, v7.0);
                                            let v604 = constructor_ineg(ctx, v2.0, v603);
                                            // Rule at src/opts/cprop.isle line 99.
                                            returns.extend(Some(v604));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        let v1077 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 7.
                                        returns.extend(Some(v1077));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                _ => {}
                            }
                        }
                        if v7.0 == v7.1 {
                            let v52 = C::ty_int(ctx, v2.0);
                            if let Some(v53) = v52 {
                                let v55 = constructor_iconst_u(ctx, v53, 0x0_u64);
                                let v56 = C::subsume(ctx, v55);
                                // Rule at src/opts/arithmetic.isle line 49.
                                returns.extend(Some(v56));
                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                            }
                        }
                        let mut v58 = C::inst_data_tupled_etor_returns::default();
                        C::inst_data_tupled_etor(ctx, v7.1, &mut v58);
                        let mut v58 = v58.into_context_iter();
                        while let Some(v59) = v58.next(ctx) {
                            let v60 = C::iconst_sextend_etor(ctx, v59);
                            if let Some(v61) = v60 {
                                let v647 = C::i64_neg(ctx, v61.1);
                                let v648 = C::i64_as_u64(ctx, v647);
                                let v649 = C::i64_as_u64(ctx, v61.1);
                                let v650 = C::u64_lt(ctx, v648, v649);
                                if v650 == true {
                                    if v2.0 == v61.0 {
                                        let v651 = C::imm64_masked(ctx, v2.0, v648);
                                        let v652 = constructor_iconst(ctx, v2.0, v651);
                                        let v653 = constructor_iadd(ctx, v2.0, v7.0, v652);
                                        // Rule at src/opts/cprop.isle line 180.
                                        returns.extend(Some(v653));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                            }
                        }
                    }
                    &Opcode::Imul => {
                        let v7 = C::unpack_value_array_2(ctx, v6);
                        let mut v10 = C::inst_data_etor_returns::default();
                        C::inst_data_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 v104,
                                    args: ref v105,
                                } => {
                                    if let &Opcode::Imul = v104 {
                                        if v2.0 == v11.0 {
                                            let v106 = C::unpack_value_array_2(ctx, v105);
                                            let mut v109 = C::inst_data_etor_returns::default();
                                            C::inst_data_etor(ctx, v106.1, &mut v109);
                                            let mut v109 = v109.into_context_iter();
                                            while let Some(v110) = v109.next(ctx) {
                                                match &v110.1 {
                                                    &InstructionData::Binary {
                                                        opcode: ref v113,
                                                        args: ref v114,
                                                    } => {
                                                        if let &Opcode::Imul = v113 {
                                                            if v2.0 == v110.0 {
                                                                let v140 = constructor_imul(ctx, v2.0, v7.0, v106.0);
                                                                let v115 = C::unpack_value_array_2(ctx, v114);
                                                                let v141 = constructor_imul(ctx, v2.0, v115.0, v115.1);
                                                                let v142 = constructor_imul(ctx, v2.0, v140, v141);
                                                                let v143 = C::subsume(ctx, v142);
                                                                // Rule at src/opts/arithmetic.isle line 139.
                                                                returns.extend(Some(v143));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                    &InstructionData::UnaryImm {
                                                        opcode: ref v686,
                                                        imm: v687,
                                                    } => {
                                                        if let &Opcode::Iconst = v686 {
                                                            let mut v18 = C::inst_data_etor_returns::default();
                                                            C::inst_data_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 v122,
                                                                    args: ref v123,
                                                                } = &v19.1 {
                                                                    if let &Opcode::Imul = v122 {
                                                                        if v2.0 == v19.0 {
                                                                            let v124 = C::unpack_value_array_2(ctx, v123);
                                                                            let mut v199 = C::inst_data_etor_returns::default();
                                                                            C::inst_data_etor(ctx, v124.1, &mut v199);
                                                                            let mut v199 = v199.into_context_iter();
                                                                            while let Some(v200) = v199.next(ctx) {
                                                                                if let &InstructionData::UnaryImm {
                                                                                    opcode: ref v226,
                                                                                    imm: v227,
                                                                                } = &v200.1 {
                                                                                    if let &Opcode::Iconst = v226 {
                                                                                        let v691 = constructor_imul(ctx, v2.0, v124.0, v106.0);
                                                                                        let v692 = constructor_imul(ctx, v2.0, v124.1, v106.1);
                                                                                        let v693 = constructor_imul(ctx, v2.0, v691, v692);
                                                                                        // Rule at src/opts/cprop.isle line 228.
                                                                                        returns.extend(Some(v693));
                                                                                        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_etor_returns::default();
                                                C::inst_data_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 v1186 = C::lane_type(ctx, v2.0);
                                                                let v1327 = constructor_imul(ctx, v1186, v30, v27);
                                                                let v1328 = constructor_splat(ctx, v2.0, v1327);
                                                                // Rule at src/opts/vector.isle line 36.
                                                                returns.extend(Some(v1328));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Ineg => {
                                            if v2.0 == v11.0 {
                                                let mut v18 = C::inst_data_etor_returns::default();
                                                C::inst_data_etor(ctx, v7.0, &mut v18);
                                                let mut v18 = v18.into_context_iter();
                                                while let Some(v19) = v18.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v29,
                                                        arg: v30,
                                                    } = &v19.1 {
                                                        if let &Opcode::Ineg = v29 {
                                                            if v2.0 == v19.0 {
                                                                let v48 = constructor_imul(ctx, v2.0, v30, v27);
                                                                let v49 = C::subsume(ctx, v48);
                                                                // Rule at src/opts/arithmetic.isle line 37.
                                                                returns.extend(Some(v49));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v14,
                                    imm: v15,
                                } => {
                                    if let &Opcode::Iconst = v14 {
                                        let v16 = C::u64_from_imm64(ctx, v15);
                                        match v16 {
                                            0x0_u64 => {
                                                if v2.0 == v11.0 {
                                                    let v57 = C::subsume(ctx, v7.1);
                                                    // Rule at src/opts/arithmetic.isle line 58.
                                                    returns.extend(Some(v57));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                            0x1_u64 => {
                                                if v2.0 == v11.0 {
                                                    let v17 = C::subsume(ctx, v7.0);
                                                    // Rule at src/opts/arithmetic.isle line 52.
                                                    returns.extend(Some(v17));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                            0x2_u64 => {
                                                let v73 = constructor_iadd(ctx, v2.0, v7.0, v7.0);
                                                // Rule at src/opts/arithmetic.isle line 91.
                                                returns.extend(Some(v73));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            _ => {}
                                        }
                                        let mut v18 = C::inst_data_etor_returns::default();
                                        C::inst_data_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 v122,
                                                    args: ref v123,
                                                } => {
                                                    if let &Opcode::Imul = v122 {
                                                        if v2.0 == v11.0 {
                                                            if v2.0 == v19.0 {
                                                                let v124 = C::unpack_value_array_2(ctx, v123);
                                                                let mut v199 = C::inst_data_etor_returns::default();
                                                                C::inst_data_etor(ctx, v124.1, &mut v199);
                                                                let mut v199 = v199.into_context_iter();
                                                                while let Some(v200) = v199.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v226,
                                                                        imm: v227,
                                                                    } = &v200.1 {
                                                                        if let &Opcode::Iconst = v226 {
                                                                            if v2.0 == v200.0 {
                                                                                let v633 = constructor_imul(ctx, v2.0, v124.1, v7.1);
                                                                                let v634 = constructor_imul(ctx, v2.0, v124.0, v633);
                                                                                // Rule at src/opts/cprop.isle line 156.
                                                                                returns.extend(Some(v634));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                &InstructionData::UnaryImm {
                                                    opcode: ref v22,
                                                    imm: v23,
                                                } => {
                                                    if let &Opcode::Iconst = v22 {
                                                        let v526 = C::fits_in_64(ctx, v2.0);
                                                        if let Some(v527) = v526 {
                                                            if v11.0 == v19.0 {
                                                                if v11.0 == v527 {
                                                                    let v24 = C::u64_from_imm64(ctx, v23);
                                                                    let v536 = C::u64_mul(ctx, v24, v16);
                                                                    let v537 = C::imm64_masked(ctx, v527, v536);
                                                                    let v538 = constructor_iconst(ctx, v527, v537);
                                                                    let v539 = C::subsume(ctx, v538);
                                                                    // Rule at src/opts/cprop.isle line 14.
                                                                    returns.extend(Some(v539));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                _ => {}
                                            }
                                        }
                                        let v74 = C::imm64_power_of_two(ctx, v15);
                                        if let Some(v75) = v74 {
                                            let v76 = C::imm64(ctx, v75);
                                            let v77 = constructor_iconst(ctx, v2.0, v76);
                                            let v78 = constructor_ishl(ctx, v2.0, v7.0, v77);
                                            // Rule at src/opts/arithmetic.isle line 98.
                                            returns.extend(Some(v78));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                        let mut v18 = C::inst_data_etor_returns::default();
                        C::inst_data_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 v122,
                                    args: ref v123,
                                } => {
                                    if let &Opcode::Imul = v122 {
                                        if v2.0 == v19.0 {
                                            let v124 = C::unpack_value_array_2(ctx, v123);
                                            let mut v127 = C::inst_data_etor_returns::default();
                                            C::inst_data_etor(ctx, v124.0, &mut v127);
                                            let mut v127 = v127.into_context_iter();
                                            while let Some(v128) = v127.next(ctx) {
                                                if let &InstructionData::Binary {
                                                    opcode: ref v131,
                                                    args: ref v132,
                                                } = &v128.1 {
                                                    if let &Opcode::Imul = v131 {
                                                        if v2.0 == v128.0 {
                                                            let v133 = C::unpack_value_array_2(ctx, v132);
                                                            let v144 = constructor_imul(ctx, v2.0, v133.0, v133.1);
                                                            let v145 = constructor_imul(ctx, v2.0, v124.1, v7.1);
                                                            let v146 = constructor_imul(ctx, v2.0, v144, v145);
                                                            let v147 = C::subsume(ctx, v146);
                                                            // Rule at src/opts/arithmetic.isle line 141.
                                                            returns.extend(Some(v147));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v22,
                                    imm: v23,
                                } => {
                                    if let &Opcode::Iconst = v22 {
                                        let v79 = C::imm64_power_of_two(ctx, v23);
                                        if let Some(v80) = v79 {
                                            let v81 = C::imm64(ctx, v80);
                                            let v82 = constructor_iconst(ctx, v2.0, v81);
                                            let v83 = constructor_ishl(ctx, v2.0, v7.1, v82);
                                            // Rule at src/opts/arithmetic.isle line 100.
                                            returns.extend(Some(v83));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        if v2.0 == v19.0 {
                                            let v605 = constructor_imul(ctx, v2.0, v7.1, v7.0);
                                            // Rule at src/opts/cprop.isle line 102.
                                            returns.extend(Some(v605));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                        let mut v58 = C::inst_data_tupled_etor_returns::default();
                        C::inst_data_tupled_etor(ctx, v7.1, &mut v58);
                        let mut v58 = v58.into_context_iter();
                        while let Some(v59) = v58.next(ctx) {
                            let v60 = C::iconst_sextend_etor(ctx, v59);
                            if let Some(v61) = v60 {
                                if v61.1 == -1_i64 {
                                    if v2.0 == v61.0 {
                                        let v64 = constructor_ineg(ctx, v2.0, v7.0);
                                        // Rule at src/opts/arithmetic.isle line 64.
                                        returns.extend(Some(v64));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                            }
                        }
                    }
                    &Opcode::Umulhi => {
                        let v7 = C::unpack_value_array_2(ctx, v6);
                        let mut v10 = C::inst_data_etor_returns::default();
                        C::inst_data_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_etor_returns::default();
                                        C::inst_data_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 v1186 = C::lane_type(ctx, v2.0);
                                                        let v1331 = constructor_umulhi(ctx, v1186, v30, v27);
                                                        let v1332 = constructor_splat(ctx, v2.0, v1331);
                                                        // Rule at src/opts/vector.isle line 42.
                                                        returns.extend(Some(v1332));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    &Opcode::Smulhi => {
                        let v7 = C::unpack_value_array_2(ctx, v6);
                        let mut v10 = C::inst_data_etor_returns::default();
                        C::inst_data_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_etor_returns::default();
                                        C::inst_data_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 v1186 = C::lane_type(ctx, v2.0);
                                                        let v1329 = constructor_smulhi(ctx, v1186, v30, v27);
                                                        let v1330 = constructor_splat(ctx, v2.0, v1329);
                                                        // Rule at src/opts/vector.isle line 39.
                                                        returns.extend(Some(v1330));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    &Opcode::Udiv => {
                        let v7 = C::unpack_value_array_2(ctx, v6);
                        let mut v10 = C::inst_data_etor_returns::default();
                        C::inst_data_etor(ctx, v7.1, &mut v10);
                        let mut v10 = v10.into_context_iter();
                        while let Some(v11) = v10.next(ctx) {
                            if let &InstructionData::UnaryImm {
                                opcode: ref v14,
                                imm: v15,
                            } = &v11.1 {
                                if let &Opcode::Iconst = v14 {
                                    let v16 = C::u64_from_imm64(ctx, v15);
                                    if v16 == 0x1_u64 {
                                        if v2.0 == v11.0 {
                                            let v17 = C::subsume(ctx, v7.0);
                                            // Rule at src/opts/arithmetic.isle line 82.
                                            returns.extend(Some(v17));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                    let v526 = C::fits_in_64(ctx, v2.0);
                                    if let Some(v527) = v526 {
                                        if v11.0 == v527 {
                                            let mut v18 = C::inst_data_etor_returns::default();
                                            C::inst_data_etor(ctx, v7.0, &mut v18);
                                            let mut v18 = v18.into_context_iter();
                                            while let Some(v19) = v18.next(ctx) {
                                                if let &InstructionData::UnaryImm {
                                                    opcode: ref v22,
                                                    imm: v23,
                                                } = &v19.1 {
                                                    if let &Opcode::Iconst = v22 {
                                                        let v24 = C::u64_from_imm64(ctx, v23);
                                                        let v545 = C::u64_udiv(ctx, v24, v16);
                                                        if let Some(v546) = v545 {
                                                            if v11.0 == v19.0 {
                                                                let v547 = C::imm64_masked(ctx, v527, v546);
                                                                let v548 = constructor_iconst(ctx, v527, v547);
                                                                let v549 = C::subsume(ctx, v548);
                                                                // Rule at src/opts/cprop.isle line 27.
                                                                returns.extend(Some(v549));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    &Opcode::Sdiv => {
                        let v7 = C::unpack_value_array_2(ctx, v6);
                        let mut v10 = C::inst_data_etor_returns::default();
                        C::inst_data_etor(ctx, v7.1, &mut v10);
                        let mut v10 = v10.into_context_iter();
                        while let Some(v11) = v10.next(ctx) {
                            if let &InstructionData::UnaryImm {
                                opcode: ref v14,
                                imm: v15,
                            } = &v11.1 {
                                if let &Opcode::Iconst = v14 {
                                    let v16 = C::u64_from_imm64(ctx, v15);
                                    if v16 == 0x1_u64 {
                                        if v2.0 == v11.0 {
                                            let v17 = C::subsume(ctx, v7.0);
                                            // Rule at src/opts/arithmetic.isle line 78.
                                            returns.extend(Some(v17));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                    let v526 = C::fits_in_64(ctx, v2.0);
                                    if let Some(v527) = v526 {
                                        if v11.0 == v527 {
                                            let mut v18 = C::inst_data_etor_returns::default();
                                            C::inst_data_etor(ctx, v7.0, &mut v18);
                                            let mut v18 = v18.into_context_iter();
                                            while let Some(v19) = v18.next(ctx) {
                                                if let &InstructionData::UnaryImm {
                                                    opcode: ref v22,
                                                    imm: v23,
                                                } = &v19.1 {
                                                    if let &Opcode::Iconst = v22 {
                                                        let v24 = C::u64_from_imm64(ctx, v23);
                                                        let v540 = C::u64_sdiv(ctx, v24, v16);
                                                        if let Some(v541) = v540 {
                                                            if v11.0 == v19.0 {
                                                                let v542 = C::imm64_masked(ctx, v527, v541);
                                                                let v543 = constructor_iconst(ctx, v527, v542);
                                                                let v544 = C::subsume(ctx, v543);
                                                                // Rule at src/opts/cprop.isle line 20.
                                                                returns.extend(Some(v544));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    &Opcode::Band => {
                        let v7 = C::unpack_value_array_2(ctx, v6);
                        let mut v10 = C::inst_data_etor_returns::default();
                        C::inst_data_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 v104,
                                    args: ref v105,
                                } => {
                                    if let &Opcode::Band = v104 {
                                        if v2.0 == v11.0 {
                                            let v106 = C::unpack_value_array_2(ctx, v105);
                                            let mut v109 = C::inst_data_etor_returns::default();
                                            C::inst_data_etor(ctx, v106.1, &mut v109);
                                            let mut v109 = v109.into_context_iter();
                                            while let Some(v110) = v109.next(ctx) {
                                                match &v110.1 {
                                                    &InstructionData::Binary {
                                                        opcode: ref v113,
                                                        args: ref v114,
                                                    } => {
                                                        if let &Opcode::Band = v113 {
                                                            if v2.0 == v110.0 {
                                                                let v148 = constructor_band(ctx, v2.0, v7.0, v106.0);
                                                                let v115 = C::unpack_value_array_2(ctx, v114);
                                                                let v149 = constructor_band(ctx, v2.0, v115.0, v115.1);
                                                                let v150 = constructor_band(ctx, v2.0, v148, v149);
                                                                let v151 = C::subsume(ctx, v150);
                                                                // Rule at src/opts/arithmetic.isle line 144.
                                                                returns.extend(Some(v151));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                    &InstructionData::UnaryImm {
                                                        opcode: ref v686,
                                                        imm: v687,
                                                    } => {
                                                        if let &Opcode::Iconst = v686 {
                                                            let mut v18 = C::inst_data_etor_returns::default();
                                                            C::inst_data_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 v122,
                                                                    args: ref v123,
                                                                } = &v19.1 {
                                                                    if let &Opcode::Band = v122 {
                                                                        if v2.0 == v19.0 {
                                                                            let v124 = C::unpack_value_array_2(ctx, v123);
                                                                            let mut v199 = C::inst_data_etor_returns::default();
                                                                            C::inst_data_etor(ctx, v124.1, &mut v199);
                                                                            let mut v199 = v199.into_context_iter();
                                                                            while let Some(v200) = v199.next(ctx) {
                                                                                if let &InstructionData::UnaryImm {
                                                                                    opcode: ref v226,
                                                                                    imm: v227,
                                                                                } = &v200.1 {
                                                                                    if let &Opcode::Iconst = v226 {
                                                                                        let v694 = constructor_band(ctx, v2.0, v124.0, v106.0);
                                                                                        let v695 = constructor_band(ctx, v2.0, v124.1, v106.1);
                                                                                        let v696 = constructor_band(ctx, v2.0, v694, v695);
                                                                                        // Rule at src/opts/cprop.isle line 232.
                                                                                        returns.extend(Some(v696));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                    _ => {}
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::IntCompare {
                                    opcode: ref v1019,
                                    args: ref v1020,
                                    cond: ref v1021,
                                } => {
                                    if let &Opcode::Icmp = v1019 {
                                        let v526 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v527) = v526 {
                                            if v11.0 == v527 {
                                                let mut v18 = C::inst_data_etor_returns::default();
                                                C::inst_data_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 v989,
                                                        args: ref v990,
                                                        cond: ref v991,
                                                    } = &v19.1 {
                                                        if let &Opcode::Icmp = v989 {
                                                            let v1025 = constructor_intcc_comparable(ctx, v991, v1021);
                                                            if let Some(v1026) = v1025 {
                                                                if v11.0 == v19.0 {
                                                                    let v992 = C::unpack_value_array_2(ctx, v990);
                                                                    let v1022 = C::unpack_value_array_2(ctx, v1020);
                                                                    if v992.0 == v1022.0 {
                                                                        if v992.1 == v1022.1 {
                                                                            let v1027 = constructor_decompose_intcc(ctx, v991);
                                                                            let v1028 = constructor_decompose_intcc(ctx, v1021);
                                                                            let v1029 = C::u64_and(ctx, v1027, v1028);
                                                                            let v1030 = constructor_compose_icmp(ctx, v527, v1029, v1026, v992.0, v992.1);
                                                                            // Rule at src/opts/icmp.isle line 145.
                                                                            returns.extend(Some(v1030));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v26,
                                    arg: v27,
                                } => {
                                    match v26 {
                                        &Opcode::Splat => {
                                            let v1313 = C::ty_vector_not_float(ctx, v2.0);
                                            if let Some(v1314) = v1313 {
                                                if v2.0 == v11.0 {
                                                    let mut v18 = C::inst_data_etor_returns::default();
                                                    C::inst_data_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 v1186 = C::lane_type(ctx, v2.0);
                                                                    let v1315 = constructor_band(ctx, v1186, v30, v27);
                                                                    let v1316 = constructor_splat(ctx, v2.0, v1315);
                                                                    // Rule at src/opts/vector.isle line 14.
                                                                    returns.extend(Some(v1316));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Bnot => {
                                            let v52 = C::ty_int(ctx, v2.0);
                                            if let Some(v53) = v52 {
                                                if v7.0 == v27 {
                                                    if v11.0 == v53 {
                                                        let v55 = constructor_iconst_u(ctx, v53, 0x0_u64);
                                                        let v56 = C::subsume(ctx, v55);
                                                        // Rule at src/opts/bitops.isle line 34.
                                                        returns.extend(Some(v56));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Uextend => {
                                            let mut v18 = C::inst_data_etor_returns::default();
                                            C::inst_data_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 v901 = C::value_type(ctx, v30);
                                                        let v936 = C::value_type(ctx, v27);
                                                        if v901 == v936 {
                                                            let v937 = constructor_band(ctx, v901, v30, v27);
                                                            let v938 = constructor_uextend(ctx, v2.0, v937);
                                                            // Rule at src/opts/extends.isle line 70.
                                                            returns.extend(Some(v938));
                                                            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_etor_returns::default();
                                        C::inst_data_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 v122,
                                                    args: ref v123,
                                                } => {
                                                    if let &Opcode::Band = v122 {
                                                        if v2.0 == v11.0 {
                                                            if v2.0 == v19.0 {
                                                                let v124 = C::unpack_value_array_2(ctx, v123);
                                                                let mut v199 = C::inst_data_etor_returns::default();
                                                                C::inst_data_etor(ctx, v124.1, &mut v199);
                                                                let mut v199 = v199.into_context_iter();
                                                                while let Some(v200) = v199.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v226,
                                                                        imm: v227,
                                                                    } = &v200.1 {
                                                                        if let &Opcode::Iconst = v226 {
                                                                            if v2.0 == v200.0 {
                                                                                let v637 = constructor_band(ctx, v2.0, v124.1, v7.1);
                                                                                let v638 = constructor_band(ctx, v2.0, v124.0, v637);
                                                                                // Rule at src/opts/cprop.isle line 162.
                                                                                returns.extend(Some(v638));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                &InstructionData::IntCompare {
                                                    opcode: ref v989,
                                                    args: ref v990,
                                                    cond: ref v991,
                                                } => {
                                                    if let &Opcode::Icmp = v989 {
                                                        let v16 = C::u64_from_imm64(ctx, v15);
                                                        if v16 == 0x1_u64 {
                                                            let v52 = C::ty_int(ctx, v2.0);
                                                            if let Some(v53) = v52 {
                                                                // Rule at src/opts/icmp.isle line 56.
                                                                returns.extend(Some(v7.0));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                                &InstructionData::Unary {
                                                    opcode: ref v29,
                                                    arg: v30,
                                                } => {
                                                    match v29 {
                                                        &Opcode::Uextend => {
                                                            let v16 = C::u64_from_imm64(ctx, v15);
                                                            if v16 == 0x1_u64 {
                                                                let v52 = C::ty_int(ctx, v2.0);
                                                                if let Some(v53) = v52 {
                                                                    let mut v995 = C::inst_data_etor_returns::default();
                                                                    C::inst_data_etor(ctx, v30, &mut v995);
                                                                    let mut v995 = v995.into_context_iter();
                                                                    while let Some(v996) = v995.next(ctx) {
                                                                        if let &InstructionData::IntCompare {
                                                                            opcode: ref v999,
                                                                            args: ref v1000,
                                                                            cond: ref v1001,
                                                                        } = &v996.1 {
                                                                            if let &Opcode::Icmp = v999 {
                                                                                // Rule at src/opts/icmp.isle line 61.
                                                                                returns.extend(Some(v7.0));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            let v901 = C::value_type(ctx, v30);
                                                            let v902 = C::ty_mask(ctx, v901);
                                                            let v903 = C::u64_and(ctx, v16, v902);
                                                            let v904 = C::u64_eq(ctx, v902, v903);
                                                            if v904 == 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 v901 = C::value_type(ctx, v30);
                                                            let v902 = C::ty_mask(ctx, v901);
                                                            let v905 = C::u64_eq(ctx, v16, v902);
                                                            if v905 == true {
                                                                let v906 = constructor_uextend(ctx, v2.0, v30);
                                                                // Rule at src/opts/extends.isle line 22.
                                                                returns.extend(Some(v906));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                &InstructionData::UnaryImm {
                                                    opcode: ref v22,
                                                    imm: v23,
                                                } => {
                                                    if let &Opcode::Iconst = v22 {
                                                        let v526 = C::fits_in_64(ctx, v2.0);
                                                        if let Some(v527) = v526 {
                                                            if v11.0 == v19.0 {
                                                                if v11.0 == v527 {
                                                                    let v24 = C::u64_from_imm64(ctx, v23);
                                                                    let v16 = C::u64_from_imm64(ctx, v15);
                                                                    let v554 = C::u64_and(ctx, v24, v16);
                                                                    let v555 = C::imm64_masked(ctx, v527, v554);
                                                                    let v556 = constructor_iconst(ctx, v527, v555);
                                                                    let v557 = C::subsume(ctx, v556);
                                                                    // Rule at src/opts/cprop.isle line 40.
                                                                    returns.extend(Some(v557));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                _ => {}
                                            }
                                        }
                                        let v16 = C::u64_from_imm64(ctx, v15);
                                        if v16 == 0x0_u64 {
                                            if v2.0 == v11.0 {
                                                let v57 = C::subsume(ctx, v7.1);
                                                // Rule at src/opts/bitops.isle line 33.
                                                returns.extend(Some(v57));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        let v1077 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 13.
                                        returns.extend(Some(v1077));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                _ => {}
                            }
                        }
                        let mut v18 = C::inst_data_etor_returns::default();
                        C::inst_data_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 v122,
                                    args: ref v123,
                                } => {
                                    if let &Opcode::Band = v122 {
                                        if v2.0 == v19.0 {
                                            let v124 = C::unpack_value_array_2(ctx, v123);
                                            let mut v127 = C::inst_data_etor_returns::default();
                                            C::inst_data_etor(ctx, v124.0, &mut v127);
                                            let mut v127 = v127.into_context_iter();
                                            while let Some(v128) = v127.next(ctx) {
                                                if let &InstructionData::Binary {
                                                    opcode: ref v131,
                                                    args: ref v132,
                                                } = &v128.1 {
                                                    if let &Opcode::Band = v131 {
                                                        if v2.0 == v128.0 {
                                                            let v133 = C::unpack_value_array_2(ctx, v132);
                                                            let v152 = constructor_band(ctx, v2.0, v133.0, v133.1);
                                                            let v153 = constructor_band(ctx, v2.0, v124.1, v7.1);
                                                            let v154 = constructor_band(ctx, v2.0, v152, v153);
                                                            let v155 = C::subsume(ctx, v154);
                                                            // Rule at src/opts/arithmetic.isle line 146.
                                                            returns.extend(Some(v155));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v29,
                                    arg: v30,
                                } => {
                                    if let &Opcode::Bnot = v29 {
                                        if v7.1 == v30 {
                                            let v52 = C::ty_int(ctx, v2.0);
                                            if let Some(v53) = v52 {
                                                if v19.0 == v53 {
                                                    let v55 = constructor_iconst_u(ctx, v53, 0x0_u64);
                                                    let v56 = C::subsume(ctx, v55);
                                                    // Rule at src/opts/bitops.isle line 35.
                                                    returns.extend(Some(v56));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v22,
                                    imm: v23,
                                } => {
                                    if let &Opcode::Iconst = v22 {
                                        if v2.0 == v19.0 {
                                            let v607 = constructor_band(ctx, v2.0, v7.1, v7.0);
                                            // Rule at src/opts/cprop.isle line 109.
                                            returns.extend(Some(v607));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        let v1077 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 11.
                                        returns.extend(Some(v1077));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                _ => {}
                            }
                        }
                        if v7.0 == v7.1 {
                            let v17 = C::subsume(ctx, v7.0);
                            // Rule at src/opts/bitops.isle line 28.
                            returns.extend(Some(v17));
                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                        }
                        let mut v58 = C::inst_data_tupled_etor_returns::default();
                        C::inst_data_tupled_etor(ctx, v7.1, &mut v58);
                        let mut v58 = v58.into_context_iter();
                        while let Some(v59) = v58.next(ctx) {
                            let v60 = C::iconst_sextend_etor(ctx, v59);
                            if let Some(v61) = v60 {
                                if v61.1 == -1_i64 {
                                    if v2.0 == v61.0 {
                                        let v17 = C::subsume(ctx, v7.0);
                                        // Rule at src/opts/bitops.isle line 29.
                                        returns.extend(Some(v17));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                            }
                        }
                    }
                    &Opcode::Bor => {
                        let v7 = C::unpack_value_array_2(ctx, v6);
                        let mut v10 = C::inst_data_etor_returns::default();
                        C::inst_data_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 v104,
                                    args: ref v105,
                                } => {
                                    match v104 {
                                        &Opcode::Band => {
                                            let mut v18 = C::inst_data_etor_returns::default();
                                            C::inst_data_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 v122,
                                                        args: ref v123,
                                                    } => {
                                                        if let &Opcode::Band = v122 {
                                                            let v1116 = C::ty_vec128(ctx, v2.0);
                                                            if let Some(v1117) = v1116 {
                                                                if v11.0 == v19.0 {
                                                                    if v11.0 == v1117 {
                                                                        let v106 = C::unpack_value_array_2(ctx, v105);
                                                                        let mut v109 = C::inst_data_etor_returns::default();
                                                                        C::inst_data_etor(ctx, v106.1, &mut v109);
                                                                        let mut v109 = v109.into_context_iter();
                                                                        while let Some(v110) = v109.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v1121,
                                                                                arg: v1122,
                                                                            } = &v110.1 {
                                                                                if let &Opcode::Bnot = v1121 {
                                                                                    if v11.0 == v110.0 {
                                                                                        let v124 = C::unpack_value_array_2(ctx, v123);
                                                                                        if v124.0 == v1122 {
                                                                                            let v1123 = constructor_bitselect(ctx, v1117, v124.0, v124.1, v106.0);
                                                                                            // Rule at src/opts/selects.isle line 70.
                                                                                            returns.extend(Some(v1123));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                        if v124.1 == v1122 {
                                                                                            let v1125 = constructor_bitselect(ctx, v1117, v124.1, v124.0, v106.0);
                                                                                            // Rule at src/opts/selects.isle line 72.
                                                                                            returns.extend(Some(v1125));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let v124 = C::unpack_value_array_2(ctx, v123);
                                                                        let mut v127 = C::inst_data_etor_returns::default();
                                                                        C::inst_data_etor(ctx, v124.0, &mut v127);
                                                                        let mut v127 = v127.into_context_iter();
                                                                        while let Some(v128) = v127.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v196,
                                                                                arg: v197,
                                                                            } = &v128.1 {
                                                                                if let &Opcode::Bnot = v196 {
                                                                                    if v11.0 == v128.0 {
                                                                                        if v106.1 == v197 {
                                                                                            let v1127 = constructor_bitselect(ctx, v1117, v197, v106.0, v124.1);
                                                                                            // Rule at src/opts/selects.isle line 74.
                                                                                            returns.extend(Some(v1127));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                        if v106.0 == v197 {
                                                                                            let v1126 = constructor_bitselect(ctx, v1117, v197, v106.1, v124.1);
                                                                                            // Rule at src/opts/selects.isle line 73.
                                                                                            returns.extend(Some(v1126));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let mut v199 = C::inst_data_etor_returns::default();
                                                                        C::inst_data_etor(ctx, v124.1, &mut v199);
                                                                        let mut v199 = v199.into_context_iter();
                                                                        while let Some(v200) = v199.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v203,
                                                                                arg: v204,
                                                                            } = &v200.1 {
                                                                                if let &Opcode::Bnot = v203 {
                                                                                    if v11.0 == v200.0 {
                                                                                        if v106.1 == v204 {
                                                                                            let v1129 = constructor_bitselect(ctx, v1117, v204, v106.0, v124.0);
                                                                                            // Rule at src/opts/selects.isle line 76.
                                                                                            returns.extend(Some(v1129));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                        if v106.0 == v204 {
                                                                                            let v1128 = constructor_bitselect(ctx, v1117, v204, v106.1, v124.0);
                                                                                            // Rule at src/opts/selects.isle line 75.
                                                                                            returns.extend(Some(v1128));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let mut v309 = C::inst_data_etor_returns::default();
                                                                        C::inst_data_etor(ctx, v106.0, &mut v309);
                                                                        let mut v309 = v309.into_context_iter();
                                                                        while let Some(v310) = v309.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v1118,
                                                                                arg: v1119,
                                                                            } = &v310.1 {
                                                                                if let &Opcode::Bnot = v1118 {
                                                                                    if v11.0 == v310.0 {
                                                                                        if v124.0 == v1119 {
                                                                                            let v1120 = constructor_bitselect(ctx, v1117, v124.0, v124.1, v106.1);
                                                                                            // Rule at src/opts/selects.isle line 69.
                                                                                            returns.extend(Some(v1120));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                        if v124.1 == v1119 {
                                                                                            let v1124 = constructor_bitselect(ctx, v1117, v124.1, v124.0, v106.1);
                                                                                            // Rule at src/opts/selects.isle line 71.
                                                                                            returns.extend(Some(v1124));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                    &InstructionData::Unary {
                                                        opcode: ref v29,
                                                        arg: v30,
                                                    } => {
                                                        if let &Opcode::Bnot = v29 {
                                                            if v2.0 == v11.0 {
                                                                if v2.0 == v19.0 {
                                                                    let v106 = C::unpack_value_array_2(ctx, v105);
                                                                    if v30 == v106.1 {
                                                                        let v225 = constructor_bor(ctx, v2.0, v106.0, v7.0);
                                                                        // Rule at src/opts/bitops.isle line 58.
                                                                        returns.extend(Some(v225));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                    _ => {}
                                                }
                                            }
                                        }
                                        &Opcode::Bor => {
                                            let mut v18 = C::inst_data_etor_returns::default();
                                            C::inst_data_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 v122,
                                                    args: ref v123,
                                                } = &v19.1 {
                                                    if let &Opcode::Bor = v122 {
                                                        let v106 = C::unpack_value_array_2(ctx, v105);
                                                        let mut v109 = C::inst_data_etor_returns::default();
                                                        C::inst_data_etor(ctx, v106.1, &mut v109);
                                                        let mut v109 = v109.into_context_iter();
                                                        while let Some(v110) = v109.next(ctx) {
                                                            match &v110.1 {
                                                                &InstructionData::Binary {
                                                                    opcode: ref v113,
                                                                    args: ref v114,
                                                                } => {
                                                                    match v113 {
                                                                        &Opcode::Bor => {
                                                                            if v2.0 == I64 {
                                                                                if v11.0 == I64 {
                                                                                    if v19.0 == I64 {
                                                                                        if v110.0 == I64 {
                                                                                            let v124 = C::unpack_value_array_2(ctx, v123);
                                                                                            let mut v127 = C::inst_data_etor_returns::default();
                                                                                            C::inst_data_etor(ctx, v124.0, &mut v127);
                                                                                            let mut v127 = v127.into_context_iter();
                                                                                            while let Some(v128) = v127.next(ctx) {
                                                                                                if v128.0 == I64 {
                                                                                                    if let &InstructionData::Binary {
                                                                                                        opcode: ref v131,
                                                                                                        args: ref v132,
                                                                                                    } = &v128.1 {
                                                                                                        if let &Opcode::Bor = v131 {
                                                                                                            let mut v199 = C::inst_data_etor_returns::default();
                                                                                                            C::inst_data_etor(ctx, v124.1, &mut v199);
                                                                                                            let mut v199 = v199.into_context_iter();
                                                                                                            while let Some(v200) = v199.next(ctx) {
                                                                                                                if v200.0 == I64 {
                                                                                                                    if let &InstructionData::Binary {
                                                                                                                        opcode: ref v281,
                                                                                                                        args: ref v282,
                                                                                                                    } = &v200.1 {
                                                                                                                        if let &Opcode::Bor = v281 {
                                                                                                                            let v133 = C::unpack_value_array_2(ctx, v132);
                                                                                                                            let mut v274 = C::inst_data_etor_returns::default();
                                                                                                                            C::inst_data_etor(ctx, v133.1, &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 v365,
                                                                                                                                        args: ref v366,
                                                                                                                                    } = &v275.1 {
                                                                                                                                        if let &Opcode::Ishl = v365 {
                                                                                                                                            let v283 = C::unpack_value_array_2(ctx, v282);
                                                                                                                                            let mut v286 = C::inst_data_etor_returns::default();
                                                                                                                                            C::inst_data_etor(ctx, v283.0, &mut v286);
                                                                                                                                            let mut v286 = v286.into_context_iter();
                                                                                                                                            while let Some(v287) = v286.next(ctx) {
                                                                                                                                                if v287.0 == I64 {
                                                                                                                                                    if let &InstructionData::Binary {
                                                                                                                                                        opcode: ref v290,
                                                                                                                                                        args: ref v291,
                                                                                                                                                    } = &v287.1 {
                                                                                                                                                        if let &Opcode::Ishl = v290 {
                                                                                                                                                            let v292 = C::unpack_value_array_2(ctx, v291);
                                                                                                                                                            let mut v295 = C::inst_data_etor_returns::default();
                                                                                                                                                            C::inst_data_etor(ctx, v292.1, &mut v295);
                                                                                                                                                            let mut v295 = v295.into_context_iter();
                                                                                                                                                            while let Some(v296) = v295.next(ctx) {
                                                                                                                                                                if v296.0 == I64 {
                                                                                                                                                                    if let &InstructionData::UnaryImm {
                                                                                                                                                                        opcode: ref v299,
                                                                                                                                                                        imm: v300,
                                                                                                                                                                    } = &v296.1 {
                                                                                                                                                                        if let &Opcode::Iconst = v299 {
                                                                                                                                                                            let v301 = C::u64_from_imm64(ctx, v300);
                                                                                                                                                                            if v301 == 0x18_u64 {
                                                                                                                                                                                let mut v302 = C::inst_data_etor_returns::default();
                                                                                                                                                                                C::inst_data_etor(ctx, v283.1, &mut v302);
                                                                                                                                                                                let mut v302 = v302.into_context_iter();
                                                                                                                                                                                while let Some(v303) = v302.next(ctx) {
                                                                                                                                                                                    if v303.0 == I64 {
                                                                                                                                                                                        if let &InstructionData::Binary {
                                                                                                                                                                                            opcode: ref v409,
                                                                                                                                                                                            args: ref v410,
                                                                                                                                                                                        } = &v303.1 {
                                                                                                                                                                                            if let &Opcode::Ishl = v409 {
                                                                                                                                                                                                let mut v309 = C::inst_data_etor_returns::default();
                                                                                                                                                                                                C::inst_data_etor(ctx, v106.0, &mut v309);
                                                                                                                                                                                                let mut v309 = v309.into_context_iter();
                                                                                                                                                                                                while let Some(v310) = v309.next(ctx) {
                                                                                                                                                                                                    if v310.0 == I64 {
                                                                                                                                                                                                        if let &InstructionData::Binary {
                                                                                                                                                                                                            opcode: ref v313,
                                                                                                                                                                                                            args: ref v314,
                                                                                                                                                                                                        } = &v310.1 {
                                                                                                                                                                                                            if let &Opcode::Bor = v313 {
                                                                                                                                                                                                                let v315 = C::unpack_value_array_2(ctx, v314);
                                                                                                                                                                                                                let mut v318 = C::inst_data_etor_returns::default();
                                                                                                                                                                                                                C::inst_data_etor(ctx, v315.0, &mut v318);
                                                                                                                                                                                                                let mut v318 = v318.into_context_iter();
                                                                                                                                                                                                                while let Some(v319) = v318.next(ctx) {
                                                                                                                                                                                                                    if v319.0 == I64 {
                                                                                                                                                                                                                        if let &InstructionData::Binary {
                                                                                                                                                                                                                            opcode: ref v322,
                                                                                                                                                                                                                            args: ref v323,
                                                                                                                                                                                                                        } = &v319.1 {
                                                                                                                                                                                                                            if let &Opcode::Band = v322 {
                                                                                                                                                                                                                                let v324 = C::unpack_value_array_2(ctx, v323);
                                                                                                                                                                                                                                let mut v327 = C::inst_data_etor_returns::default();
                                                                                                                                                                                                                                C::inst_data_etor(ctx, v324.1, &mut v327);
                                                                                                                                                                                                                                let mut v327 = v327.into_context_iter();
                                                                                                                                                                                                                                while let Some(v328) = v327.next(ctx) {
                                                                                                                                                                                                                                    if v328.0 == I64 {
                                                                                                                                                                                                                                        if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                            opcode: ref v331,
                                                                                                                                                                                                                                            imm: v332,
                                                                                                                                                                                                                                        } = &v328.1 {
                                                                                                                                                                                                                                            if let &Opcode::Iconst = v331 {
                                                                                                                                                                                                                                                let v333 = C::u64_from_imm64(ctx, v332);
                                                                                                                                                                                                                                                if v333 == 0xff000000_u64 {
                                                                                                                                                                                                                                                    let mut v334 = C::inst_data_etor_returns::default();
                                                                                                                                                                                                                                                    C::inst_data_etor(ctx, v315.1, &mut v334);
                                                                                                                                                                                                                                                    let mut v334 = v334.into_context_iter();
                                                                                                                                                                                                                                                    while let Some(v335) = v334.next(ctx) {
                                                                                                                                                                                                                                                        if v335.0 == I64 {
                                                                                                                                                                                                                                                            if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                opcode: ref v453,
                                                                                                                                                                                                                                                                args: ref v454,
                                                                                                                                                                                                                                                            } = &v335.1 {
                                                                                                                                                                                                                                                                if let &Opcode::Band = v453 {
                                                                                                                                                                                                                                                                    let v115 = C::unpack_value_array_2(ctx, v114);
                                                                                                                                                                                                                                                                    let mut v341 = C::inst_data_etor_returns::default();
                                                                                                                                                                                                                                                                    C::inst_data_etor(ctx, v115.1, &mut v341);
                                                                                                                                                                                                                                                                    let mut v341 = v341.into_context_iter();
                                                                                                                                                                                                                                                                    while let Some(v342) = v341.next(ctx) {
                                                                                                                                                                                                                                                                        if v342.0 == I64 {
                                                                                                                                                                                                                                                                            if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                                opcode: ref v513,
                                                                                                                                                                                                                                                                                args: ref v514,
                                                                                                                                                                                                                                                                            } = &v342.1 {
                                                                                                                                                                                                                                                                                if let &Opcode::Ushr = v513 {
                                                                                                                                                                                                                                                                                    let mut v349 = C::inst_data_etor_returns::default();
                                                                                                                                                                                                                                                                                    C::inst_data_etor(ctx, v133.0, &mut v349);
                                                                                                                                                                                                                                                                                    let mut v349 = v349.into_context_iter();
                                                                                                                                                                                                                                                                                    while let Some(v350) = v349.next(ctx) {
                                                                                                                                                                                                                                                                                        if v350.0 == I64 {
                                                                                                                                                                                                                                                                                            if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                                                opcode: ref v353,
                                                                                                                                                                                                                                                                                                args: ref v354,
                                                                                                                                                                                                                                                                                            } = &v350.1 {
                                                                                                                                                                                                                                                                                                if let &Opcode::Ishl = v353 {
                                                                                                                                                                                                                                                                                                    let v355 = C::unpack_value_array_2(ctx, v354);
                                                                                                                                                                                                                                                                                                    let v515 = C::unpack_value_array_2(ctx, v514);
                                                                                                                                                                                                                                                                                                    if v355.0 == v515.0 {
                                                                                                                                                                                                                                                                                                        let mut v358 = C::inst_data_etor_returns::default();
                                                                                                                                                                                                                                                                                                        C::inst_data_etor(ctx, v355.1, &mut v358);
                                                                                                                                                                                                                                                                                                        let mut v358 = v358.into_context_iter();
                                                                                                                                                                                                                                                                                                        while let Some(v359) = v358.next(ctx) {
                                                                                                                                                                                                                                                                                                            if v359.0 == I64 {
                                                                                                                                                                                                                                                                                                                if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                    opcode: ref v362,
                                                                                                                                                                                                                                                                                                                    imm: v363,
                                                                                                                                                                                                                                                                                                                } = &v359.1 {
                                                                                                                                                                                                                                                                                                                    if let &Opcode::Iconst = v362 {
                                                                                                                                                                                                                                                                                                                        let v364 = C::u64_from_imm64(ctx, v363);
                                                                                                                                                                                                                                                                                                                        if v364 == 0x38_u64 {
                                                                                                                                                                                                                                                                                                                            let v367 = C::unpack_value_array_2(ctx, v366);
                                                                                                                                                                                                                                                                                                                            let mut v370 = C::inst_data_etor_returns::default();
                                                                                                                                                                                                                                                                                                                            C::inst_data_etor(ctx, v367.0, &mut v370);
                                                                                                                                                                                                                                                                                                                            let mut v370 = v370.into_context_iter();
                                                                                                                                                                                                                                                                                                                            while let Some(v371) = v370.next(ctx) {
                                                                                                                                                                                                                                                                                                                                if v371.0 == I64 {
                                                                                                                                                                                                                                                                                                                                    if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                                                                                        opcode: ref v374,
                                                                                                                                                                                                                                                                                                                                        args: ref v375,
                                                                                                                                                                                                                                                                                                                                    } = &v371.1 {
                                                                                                                                                                                                                                                                                                                                        if let &Opcode::Band = v374 {
                                                                                                                                                                                                                                                                                                                                            let v376 = C::unpack_value_array_2(ctx, v375);
                                                                                                                                                                                                                                                                                                                                            if v355.0 == v376.0 {
                                                                                                                                                                                                                                                                                                                                                let mut v379 = C::inst_data_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                C::inst_data_etor(ctx, v376.1, &mut v379);
                                                                                                                                                                                                                                                                                                                                                let mut v379 = v379.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                while let Some(v380) = v379.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                    if v380.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                        if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                            opcode: ref v383,
                                                                                                                                                                                                                                                                                                                                                            imm: v384,
                                                                                                                                                                                                                                                                                                                                                        } = &v380.1 {
                                                                                                                                                                                                                                                                                                                                                            if let &Opcode::Iconst = v383 {
                                                                                                                                                                                                                                                                                                                                                                let v385 = C::u64_from_imm64(ctx, v384);
                                                                                                                                                                                                                                                                                                                                                                if v385 == 0xff00_u64 {
                                                                                                                                                                                                                                                                                                                                                                    let mut v386 = C::inst_data_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                    C::inst_data_etor(ctx, v367.1, &mut v386);
                                                                                                                                                                                                                                                                                                                                                                    let mut v386 = v386.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                    while let Some(v387) = v386.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                        if v387.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                            if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                                opcode: ref v390,
                                                                                                                                                                                                                                                                                                                                                                                imm: v391,
                                                                                                                                                                                                                                                                                                                                                                            } = &v387.1 {
                                                                                                                                                                                                                                                                                                                                                                                if let &Opcode::Iconst = v390 {
                                                                                                                                                                                                                                                                                                                                                                                    let v392 = C::u64_from_imm64(ctx, v391);
                                                                                                                                                                                                                                                                                                                                                                                    if v392 == 0x28_u64 {
                                                                                                                                                                                                                                                                                                                                                                                        let mut v393 = C::inst_data_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                        C::inst_data_etor(ctx, v292.0, &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 v397,
                                                                                                                                                                                                                                                                                                                                                                                                    args: ref v398,
                                                                                                                                                                                                                                                                                                                                                                                                } = &v394.1 {
                                                                                                                                                                                                                                                                                                                                                                                                    if let &Opcode::Band = v397 {
                                                                                                                                                                                                                                                                                                                                                                                                        let v399 = C::unpack_value_array_2(ctx, v398);
                                                                                                                                                                                                                                                                                                                                                                                                        if v355.0 == v399.0 {
                                                                                                                                                                                                                                                                                                                                                                                                            let mut v402 = C::inst_data_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                            C::inst_data_etor(ctx, v399.1, &mut v402);
                                                                                                                                                                                                                                                                                                                                                                                                            let mut v402 = v402.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                            while let Some(v403) = v402.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                if v403.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                    if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                                                                        opcode: ref v406,
                                                                                                                                                                                                                                                                                                                                                                                                                        imm: v407,
                                                                                                                                                                                                                                                                                                                                                                                                                    } = &v403.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                        if let &Opcode::Iconst = v406 {
                                                                                                                                                                                                                                                                                                                                                                                                                            let v408 = C::u64_from_imm64(ctx, v407);
                                                                                                                                                                                                                                                                                                                                                                                                                            if v408 == 0xff0000_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                let v411 = C::unpack_value_array_2(ctx, v410);
                                                                                                                                                                                                                                                                                                                                                                                                                                let mut v414 = C::inst_data_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                C::inst_data_etor(ctx, v411.0, &mut v414);
                                                                                                                                                                                                                                                                                                                                                                                                                                let mut v414 = v414.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                while let Some(v415) = v414.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                    if v415.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                        if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                                                                                                                                                                                            opcode: ref v418,
                                                                                                                                                                                                                                                                                                                                                                                                                                            args: ref v419,
                                                                                                                                                                                                                                                                                                                                                                                                                                        } = &v415.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                            if let &Opcode::Band = v418 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                let v420 = C::unpack_value_array_2(ctx, v419);
                                                                                                                                                                                                                                                                                                                                                                                                                                                if v355.0 == v420.0 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mut v423 = C::inst_data_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                    C::inst_data_etor(ctx, v420.1, &mut v423);
                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mut v423 = v423.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                    while let Some(v424) = v423.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                        if v424.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                            if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                opcode: ref v427,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                imm: v428,
                                                                                                                                                                                                                                                                                                                                                                                                                                                            } = &v424.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                if let &Opcode::Iconst = v427 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let v429 = C::u64_from_imm64(ctx, v428);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if v429 == 0xff000000_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mut v430 = C::inst_data_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        C::inst_data_etor(ctx, v411.1, &mut v430);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mut v430 = v430.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        while let Some(v431) = v430.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if v431.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opcode: ref v434,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    imm: v435,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } = &v431.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if let &Opcode::Iconst = v434 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let v436 = C::u64_from_imm64(ctx, v435);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if v436 == 0x8_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mut v437 = C::inst_data_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            C::inst_data_etor(ctx, v324.0, &mut v437);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mut v437 = v437.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            while let Some(v438) = v437.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if v438.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opcode: ref v441,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        args: ref v442,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } = &v438.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if let &Opcode::Ushr = v441 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let v443 = C::unpack_value_array_2(ctx, v442);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if v355.0 == v443.0 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mut v446 = C::inst_data_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                C::inst_data_etor(ctx, v443.1, &mut v446);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mut v446 = v446.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                while let Some(v447) = v446.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if v447.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        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 == 0x8_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let v455 = C::unpack_value_array_2(ctx, v454);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mut v458 = C::inst_data_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    C::inst_data_etor(ctx, v455.0, &mut v458);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mut v458 = v458.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    while let Some(v459) = v458.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if v459.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                opcode: ref v462,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                args: ref v463,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } = &v459.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if let &Opcode::Ushr = v462 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let v464 = C::unpack_value_array_2(ctx, v463);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if v355.0 == v464.0 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mut v467 = C::inst_data_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        C::inst_data_etor(ctx, v464.1, &mut v467);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mut v467 = v467.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        while let Some(v468) = v467.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if v468.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opcode: ref v471,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    imm: v472,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } = &v468.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if let &Opcode::Iconst = v471 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let v473 = C::u64_from_imm64(ctx, v472);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if v473 == 0x18_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mut v474 = C::inst_data_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            C::inst_data_etor(ctx, v455.1, &mut v474);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mut v474 = v474.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            while let Some(v475) = v474.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if v475.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opcode: ref v478,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        imm: v479,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } = &v475.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if let &Opcode::Iconst = v478 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let v480 = C::u64_from_imm64(ctx, v479);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if v480 == 0xff0000_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mut v481 = C::inst_data_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                C::inst_data_etor(ctx, v115.0, &mut v481);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mut v481 = v481.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                while let Some(v482) = v481.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if v482.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            opcode: ref v485,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            args: ref v486,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } = &v482.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if let &Opcode::Band = v485 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let v487 = C::unpack_value_array_2(ctx, v486);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mut v490 = C::inst_data_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                C::inst_data_etor(ctx, v487.0, &mut v490);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mut v490 = v490.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                while let Some(v491) = v490.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if v491.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            opcode: ref v494,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            args: ref v495,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } = &v491.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if let &Opcode::Ushr = v494 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let v496 = C::unpack_value_array_2(ctx, v495);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if v355.0 == v496.0 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mut v499 = C::inst_data_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    C::inst_data_etor(ctx, v496.1, &mut v499);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mut v499 = v499.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    while let Some(v500) = v499.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if v500.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                opcode: ref v503,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                imm: v504,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } = &v500.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if let &Opcode::Iconst = v503 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let v505 = C::u64_from_imm64(ctx, v504);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if v505 == 0x28_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mut v506 = C::inst_data_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        C::inst_data_etor(ctx, v487.1, &mut v506);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mut v506 = v506.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        while let Some(v507) = v506.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if v507.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opcode: ref v510,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    imm: v511,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } = &v507.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if let &Opcode::Iconst = v510 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let v512 = C::u64_from_imm64(ctx, v511);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if v512 == 0xff00_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mut v518 = C::inst_data_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            C::inst_data_etor(ctx, v515.1, &mut v518);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mut v518 = v518.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            while let Some(v519) = v518.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if v519.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opcode: ref v522,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        imm: v523,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } = &v519.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if let &Opcode::Iconst = v522 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let v524 = C::u64_from_imm64(ctx, v523);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if v524 == 0x38_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let v525 = constructor_bswap(ctx, v2.0, v355.0);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                // Rule at src/opts/bitops.isle line 160.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                returns.extend(Some(v525));
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                }
                                                                                                                                                                                                                            }
                                                                                                                                                                                                                        }
                                                                                                                                                                                                                    }
                                                                                                                                                                                                                }
                                                                                                                                                                                                            }
                                                                                                                                                                                                        }
                                                                                                                                                                                                    }
                                                                                                                                                                                                }
                                                                                                                                                                                            }
                                                                                                                                                                                        }
                                                                                                                                                                                    }
                                                                                                                                                                                }
                                                                                                                                                                            }
                                                                                                                                                                        }
                                                                                                                                                                    }
                                                                                                                                                                }
                                                                                                                                                            }
                                                                                                                                                        }
                                                                                                                                                    }
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        &Opcode::Ushr => {
                                                                            if v2.0 == I32 {
                                                                                if v11.0 == I32 {
                                                                                    if v19.0 == I32 {
                                                                                        if v110.0 == I32 {
                                                                                            let v124 = C::unpack_value_array_2(ctx, v123);
                                                                                            let mut v127 = C::inst_data_etor_returns::default();
                                                                                            C::inst_data_etor(ctx, v124.0, &mut v127);
                                                                                            let mut v127 = v127.into_context_iter();
                                                                                            while let Some(v128) = v127.next(ctx) {
                                                                                                if v128.0 == I32 {
                                                                                                    if let &InstructionData::Binary {
                                                                                                        opcode: ref v131,
                                                                                                        args: ref v132,
                                                                                                    } = &v128.1 {
                                                                                                        if let &Opcode::Ishl = v131 {
                                                                                                            let v115 = C::unpack_value_array_2(ctx, v114);
                                                                                                            let v133 = C::unpack_value_array_2(ctx, v132);
                                                                                                            if v115.0 == v133.0 {
                                                                                                                let mut v199 = C::inst_data_etor_returns::default();
                                                                                                                C::inst_data_etor(ctx, v124.1, &mut v199);
                                                                                                                let mut v199 = v199.into_context_iter();
                                                                                                                while let Some(v200) = v199.next(ctx) {
                                                                                                                    if v200.0 == I32 {
                                                                                                                        if let &InstructionData::Binary {
                                                                                                                            opcode: ref v281,
                                                                                                                            args: ref v282,
                                                                                                                        } = &v200.1 {
                                                                                                                            if let &Opcode::Ishl = v281 {
                                                                                                                                let mut v274 = C::inst_data_etor_returns::default();
                                                                                                                                C::inst_data_etor(ctx, v133.1, &mut v274);
                                                                                                                                let mut v274 = v274.into_context_iter();
                                                                                                                                while let Some(v275) = v274.next(ctx) {
                                                                                                                                    if v275.0 == I32 {
                                                                                                                                        if let &InstructionData::UnaryImm {
                                                                                                                                            opcode: ref v278,
                                                                                                                                            imm: v279,
                                                                                                                                        } = &v275.1 {
                                                                                                                                            if let &Opcode::Iconst = v278 {
                                                                                                                                                let v280 = C::u64_from_imm64(ctx, v279);
                                                                                                                                                if v280 == 0x18_u64 {
                                                                                                                                                    let v283 = C::unpack_value_array_2(ctx, v282);
                                                                                                                                                    let mut v286 = C::inst_data_etor_returns::default();
                                                                                                                                                    C::inst_data_etor(ctx, v283.0, &mut v286);
                                                                                                                                                    let mut v286 = v286.into_context_iter();
                                                                                                                                                    while let Some(v287) = v286.next(ctx) {
                                                                                                                                                        if v287.0 == I32 {
                                                                                                                                                            if let &InstructionData::Binary {
                                                                                                                                                                opcode: ref v290,
                                                                                                                                                                args: ref v291,
                                                                                                                                                            } = &v287.1 {
                                                                                                                                                                if let &Opcode::Band = v290 {
                                                                                                                                                                    let v292 = C::unpack_value_array_2(ctx, v291);
                                                                                                                                                                    if v115.0 == v292.0 {
                                                                                                                                                                        let mut v295 = C::inst_data_etor_returns::default();
                                                                                                                                                                        C::inst_data_etor(ctx, v292.1, &mut v295);
                                                                                                                                                                        let mut v295 = v295.into_context_iter();
                                                                                                                                                                        while let Some(v296) = v295.next(ctx) {
                                                                                                                                                                            if v296.0 == I32 {
                                                                                                                                                                                if let &InstructionData::UnaryImm {
                                                                                                                                                                                    opcode: ref v299,
                                                                                                                                                                                    imm: v300,
                                                                                                                                                                                } = &v296.1 {
                                                                                                                                                                                    if let &Opcode::Iconst = v299 {
                                                                                                                                                                                        let v301 = C::u64_from_imm64(ctx, v300);
                                                                                                                                                                                        if v301 == 0xff00_u64 {
                                                                                                                                                                                            let mut v302 = C::inst_data_etor_returns::default();
                                                                                                                                                                                            C::inst_data_etor(ctx, v283.1, &mut v302);
                                                                                                                                                                                            let mut v302 = v302.into_context_iter();
                                                                                                                                                                                            while let Some(v303) = v302.next(ctx) {
                                                                                                                                                                                                if v303.0 == I32 {
                                                                                                                                                                                                    if let &InstructionData::UnaryImm {
                                                                                                                                                                                                        opcode: ref v306,
                                                                                                                                                                                                        imm: v307,
                                                                                                                                                                                                    } = &v303.1 {
                                                                                                                                                                                                        if let &Opcode::Iconst = v306 {
                                                                                                                                                                                                            let v308 = C::u64_from_imm64(ctx, v307);
                                                                                                                                                                                                            if v308 == 0x8_u64 {
                                                                                                                                                                                                                let mut v309 = C::inst_data_etor_returns::default();
                                                                                                                                                                                                                C::inst_data_etor(ctx, v106.0, &mut v309);
                                                                                                                                                                                                                let mut v309 = v309.into_context_iter();
                                                                                                                                                                                                                while let Some(v310) = v309.next(ctx) {
                                                                                                                                                                                                                    if v310.0 == I32 {
                                                                                                                                                                                                                        if let &InstructionData::Binary {
                                                                                                                                                                                                                            opcode: ref v313,
                                                                                                                                                                                                                            args: ref v314,
                                                                                                                                                                                                                        } = &v310.1 {
                                                                                                                                                                                                                            if let &Opcode::Band = v313 {
                                                                                                                                                                                                                                let v315 = C::unpack_value_array_2(ctx, v314);
                                                                                                                                                                                                                                let mut v318 = C::inst_data_etor_returns::default();
                                                                                                                                                                                                                                C::inst_data_etor(ctx, v315.0, &mut v318);
                                                                                                                                                                                                                                let mut v318 = v318.into_context_iter();
                                                                                                                                                                                                                                while let Some(v319) = v318.next(ctx) {
                                                                                                                                                                                                                                    if v319.0 == I32 {
                                                                                                                                                                                                                                        if let &InstructionData::Binary {
                                                                                                                                                                                                                                            opcode: ref v322,
                                                                                                                                                                                                                                            args: ref v323,
                                                                                                                                                                                                                                        } = &v319.1 {
                                                                                                                                                                                                                                            if let &Opcode::Ushr = v322 {
                                                                                                                                                                                                                                                let v324 = C::unpack_value_array_2(ctx, v323);
                                                                                                                                                                                                                                                if v115.0 == v324.0 {
                                                                                                                                                                                                                                                    let mut v327 = C::inst_data_etor_returns::default();
                                                                                                                                                                                                                                                    C::inst_data_etor(ctx, v324.1, &mut v327);
                                                                                                                                                                                                                                                    let mut v327 = v327.into_context_iter();
                                                                                                                                                                                                                                                    while let Some(v328) = v327.next(ctx) {
                                                                                                                                                                                                                                                        if v328.0 == I32 {
                                                                                                                                                                                                                                                            if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                opcode: ref v331,
                                                                                                                                                                                                                                                                imm: v332,
                                                                                                                                                                                                                                                            } = &v328.1 {
                                                                                                                                                                                                                                                                if let &Opcode::Iconst = v331 {
                                                                                                                                                                                                                                                                    let v333 = C::u64_from_imm64(ctx, v332);
                                                                                                                                                                                                                                                                    if v333 == 0x8_u64 {
                                                                                                                                                                                                                                                                        let mut v334 = C::inst_data_etor_returns::default();
                                                                                                                                                                                                                                                                        C::inst_data_etor(ctx, v315.1, &mut v334);
                                                                                                                                                                                                                                                                        let mut v334 = v334.into_context_iter();
                                                                                                                                                                                                                                                                        while let Some(v335) = v334.next(ctx) {
                                                                                                                                                                                                                                                                            if v335.0 == I32 {
                                                                                                                                                                                                                                                                                if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                    opcode: ref v338,
                                                                                                                                                                                                                                                                                    imm: v339,
                                                                                                                                                                                                                                                                                } = &v335.1 {
                                                                                                                                                                                                                                                                                    if let &Opcode::Iconst = v338 {
                                                                                                                                                                                                                                                                                        let v340 = C::u64_from_imm64(ctx, v339);
                                                                                                                                                                                                                                                                                        if v340 == 0xff00_u64 {
                                                                                                                                                                                                                                                                                            let mut v341 = C::inst_data_etor_returns::default();
                                                                                                                                                                                                                                                                                            C::inst_data_etor(ctx, v115.1, &mut v341);
                                                                                                                                                                                                                                                                                            let mut v341 = v341.into_context_iter();
                                                                                                                                                                                                                                                                                            while let Some(v342) = v341.next(ctx) {
                                                                                                                                                                                                                                                                                                if v342.0 == I32 {
                                                                                                                                                                                                                                                                                                    if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                        opcode: ref v345,
                                                                                                                                                                                                                                                                                                        imm: v346,
                                                                                                                                                                                                                                                                                                    } = &v342.1 {
                                                                                                                                                                                                                                                                                                        if let &Opcode::Iconst = v345 {
                                                                                                                                                                                                                                                                                                            let v347 = C::u64_from_imm64(ctx, v346);
                                                                                                                                                                                                                                                                                                            if v347 == 0x18_u64 {
                                                                                                                                                                                                                                                                                                                let v348 = constructor_bswap(ctx, v2.0, v133.0);
                                                                                                                                                                                                                                                                                                                // Rule at src/opts/bitops.isle line 147.
                                                                                                                                                                                                                                                                                                                returns.extend(Some(v348));
                                                                                                                                                                                                                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                }
                                                                                                                                                                                                                            }
                                                                                                                                                                                                                        }
                                                                                                                                                                                                                    }
                                                                                                                                                                                                                }
                                                                                                                                                                                                            }
                                                                                                                                                                                                        }
                                                                                                                                                                                                    }
                                                                                                                                                                                                }
                                                                                                                                                                                            }
                                                                                                                                                                                        }
                                                                                                                                                                                    }
                                                                                                                                                                                }
                                                                                                                                                                            }
                                                                                                                                                                        }
                                                                                                                                                                    }
                                                                                                                                                                }
                                                                                                                                                            }
                                                                                                                                                        }
                                                                                                                                                    }
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        _ => {}
                                                                    }
                                                                }
                                                                &InstructionData::UnaryImm {
                                                                    opcode: ref v686,
                                                                    imm: v687,
                                                                } => {
                                                                    if let &Opcode::Iconst = v686 {
                                                                        if v2.0 == v11.0 {
                                                                            if v2.0 == v19.0 {
                                                                                let v124 = C::unpack_value_array_2(ctx, v123);
                                                                                let mut v199 = C::inst_data_etor_returns::default();
                                                                                C::inst_data_etor(ctx, v124.1, &mut v199);
                                                                                let mut v199 = v199.into_context_iter();
                                                                                while let Some(v200) = v199.next(ctx) {
                                                                                    if let &InstructionData::UnaryImm {
                                                                                        opcode: ref v226,
                                                                                        imm: v227,
                                                                                    } = &v200.1 {
                                                                                        if let &Opcode::Iconst = v226 {
                                                                                            let v697 = constructor_bor(ctx, v2.0, v124.0, v106.0);
                                                                                            let v698 = constructor_bor(ctx, v2.0, v124.1, v106.1);
                                                                                            let v699 = constructor_bor(ctx, v2.0, v697, v698);
                                                                                            // Rule at src/opts/cprop.isle line 236.
                                                                                            returns.extend(Some(v699));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Ishl => {
                                            let v52 = C::ty_int(ctx, v2.0);
                                            if let Some(v53) = v52 {
                                                if v11.0 == v53 {
                                                    let mut v18 = C::inst_data_etor_returns::default();
                                                    C::inst_data_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 v122,
                                                            args: ref v123,
                                                        } = &v19.1 {
                                                            if let &Opcode::Ushr = v122 {
                                                                if v11.0 == v19.0 {
                                                                    let v106 = C::unpack_value_array_2(ctx, v105);
                                                                    let v124 = C::unpack_value_array_2(ctx, v123);
                                                                    if v106.0 == v124.0 {
                                                                        let mut v109 = C::inst_data_etor_returns::default();
                                                                        C::inst_data_etor(ctx, v106.1, &mut v109);
                                                                        let mut v109 = v109.into_context_iter();
                                                                        while let Some(v110) = v109.next(ctx) {
                                                                            if let &InstructionData::UnaryImm {
                                                                                opcode: ref v686,
                                                                                imm: v687,
                                                                            } = &v110.1 {
                                                                                if let &Opcode::Iconst = v686 {
                                                                                    let mut v199 = C::inst_data_etor_returns::default();
                                                                                    C::inst_data_etor(ctx, v124.1, &mut v199);
                                                                                    let mut v199 = v199.into_context_iter();
                                                                                    while let Some(v200) = v199.next(ctx) {
                                                                                        if let &InstructionData::UnaryImm {
                                                                                            opcode: ref v226,
                                                                                            imm: v227,
                                                                                        } = &v200.1 {
                                                                                            if let &Opcode::Iconst = v226 {
                                                                                                let v228 = C::u64_from_imm64(ctx, v227);
                                                                                                let v1203 = C::lane_type(ctx, v53);
                                                                                                let v1204 = C::ty_bits_u64(ctx, v1203);
                                                                                                let v956 = C::u64_from_imm64(ctx, v687);
                                                                                                let v1208 = C::u64_sub(ctx, v1204, v956);
                                                                                                let v1209 = C::u64_eq(ctx, v228, v1208);
                                                                                                if v1209 == true {
                                                                                                    let v1210 = constructor_rotl(ctx, v53, v124.0, v106.1);
                                                                                                    // Rule at src/opts/shifts.isle line 280.
                                                                                                    returns.extend(Some(v1210));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Ushr => {
                                            let v52 = C::ty_int(ctx, v2.0);
                                            if let Some(v53) = v52 {
                                                if v11.0 == v53 {
                                                    let mut v18 = C::inst_data_etor_returns::default();
                                                    C::inst_data_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 v122,
                                                            args: ref v123,
                                                        } = &v19.1 {
                                                            if let &Opcode::Ishl = v122 {
                                                                if v11.0 == v19.0 {
                                                                    let v106 = C::unpack_value_array_2(ctx, v105);
                                                                    let v124 = C::unpack_value_array_2(ctx, v123);
                                                                    if v106.0 == v124.0 {
                                                                        let mut v109 = C::inst_data_etor_returns::default();
                                                                        C::inst_data_etor(ctx, v106.1, &mut v109);
                                                                        let mut v109 = v109.into_context_iter();
                                                                        while let Some(v110) = v109.next(ctx) {
                                                                            if let &InstructionData::UnaryImm {
                                                                                opcode: ref v686,
                                                                                imm: v687,
                                                                            } = &v110.1 {
                                                                                if let &Opcode::Iconst = v686 {
                                                                                    let mut v199 = C::inst_data_etor_returns::default();
                                                                                    C::inst_data_etor(ctx, v124.1, &mut v199);
                                                                                    let mut v199 = v199.into_context_iter();
                                                                                    while let Some(v200) = v199.next(ctx) {
                                                                                        if let &InstructionData::UnaryImm {
                                                                                            opcode: ref v226,
                                                                                            imm: v227,
                                                                                        } = &v200.1 {
                                                                                            if let &Opcode::Iconst = v226 {
                                                                                                let v956 = C::u64_from_imm64(ctx, v687);
                                                                                                let v1203 = C::lane_type(ctx, v53);
                                                                                                let v1204 = C::ty_bits_u64(ctx, v1203);
                                                                                                let v228 = C::u64_from_imm64(ctx, v227);
                                                                                                let v1205 = C::u64_sub(ctx, v1204, v228);
                                                                                                let v1206 = C::u64_eq(ctx, v956, v1205);
                                                                                                if v1206 == true {
                                                                                                    let v1207 = constructor_rotl(ctx, v53, v124.0, v124.1);
                                                                                                    // Rule at src/opts/shifts.isle line 275.
                                                                                                    returns.extend(Some(v1207));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::IntCompare {
                                    opcode: ref v1019,
                                    args: ref v1020,
                                    cond: ref v1021,
                                } => {
                                    if let &Opcode::Icmp = v1019 {
                                        let v526 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v527) = v526 {
                                            if v11.0 == v527 {
                                                let mut v18 = C::inst_data_etor_returns::default();
                                                C::inst_data_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 v989,
                                                        args: ref v990,
                                                        cond: ref v991,
                                                    } = &v19.1 {
                                                        if let &Opcode::Icmp = v989 {
                                                            let v1025 = constructor_intcc_comparable(ctx, v991, v1021);
                                                            if let Some(v1026) = v1025 {
                                                                if v11.0 == v19.0 {
                                                                    let v992 = C::unpack_value_array_2(ctx, v990);
                                                                    let v1022 = C::unpack_value_array_2(ctx, v1020);
                                                                    if v992.0 == v1022.0 {
                                                                        if v992.1 == v1022.1 {
                                                                            let v1027 = constructor_decompose_intcc(ctx, v991);
                                                                            let v1028 = constructor_decompose_intcc(ctx, v1021);
                                                                            let v1031 = C::u64_or(ctx, v1027, v1028);
                                                                            let v1032 = constructor_compose_icmp(ctx, v527, v1031, v1026, v992.0, v992.1);
                                                                            // Rule at src/opts/icmp.isle line 149.
                                                                            returns.extend(Some(v1032));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v26,
                                    arg: v27,
                                } => {
                                    match v26 {
                                        &Opcode::Splat => {
                                            let v1313 = C::ty_vector_not_float(ctx, v2.0);
                                            if let Some(v1314) = v1313 {
                                                if v2.0 == v11.0 {
                                                    let mut v18 = C::inst_data_etor_returns::default();
                                                    C::inst_data_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 v1186 = C::lane_type(ctx, v2.0);
                                                                    let v1317 = constructor_bor(ctx, v1186, v30, v27);
                                                                    let v1318 = constructor_splat(ctx, v2.0, v1317);
                                                                    // Rule at src/opts/vector.isle line 18.
                                                                    returns.extend(Some(v1318));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Bnot => {
                                            let v52 = C::ty_int(ctx, v2.0);
                                            if let Some(v53) = v52 {
                                                if v7.0 == v27 {
                                                    if v11.0 == v53 {
                                                        let v218 = constructor_iconst_s(ctx, v53, -1_i64);
                                                        let v219 = C::subsume(ctx, v218);
                                                        // Rule at src/opts/bitops.isle line 24.
                                                        returns.extend(Some(v219));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            if v2.0 == v11.0 {
                                                let mut v18 = C::inst_data_etor_returns::default();
                                                C::inst_data_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 v122,
                                                        args: ref v123,
                                                    } = &v19.1 {
                                                        if let &Opcode::Band = v122 {
                                                            if v2.0 == v19.0 {
                                                                let v124 = C::unpack_value_array_2(ctx, v123);
                                                                if v27 == v124.1 {
                                                                    let v224 = constructor_bor(ctx, v2.0, v124.0, v7.1);
                                                                    // Rule at src/opts/bitops.isle line 49.
                                                                    returns.extend(Some(v224));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Uextend => {
                                            let mut v18 = C::inst_data_etor_returns::default();
                                            C::inst_data_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 v901 = C::value_type(ctx, v30);
                                                        let v936 = C::value_type(ctx, v27);
                                                        if v901 == v936 {
                                                            let v939 = constructor_bor(ctx, v901, v30, v27);
                                                            let v940 = constructor_uextend(ctx, v2.0, v939);
                                                            // Rule at src/opts/extends.isle line 72.
                                                            returns.extend(Some(v940));
                                                            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_etor_returns::default();
                                            C::inst_data_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 v122,
                                                    args: ref v123,
                                                } = &v19.1 {
                                                    match v122 {
                                                        &Opcode::Band => {
                                                            if v2.0 == v19.0 {
                                                                let v124 = C::unpack_value_array_2(ctx, v123);
                                                                let mut v199 = C::inst_data_etor_returns::default();
                                                                C::inst_data_etor(ctx, v124.1, &mut v199);
                                                                let mut v199 = v199.into_context_iter();
                                                                while let Some(v200) = v199.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v226,
                                                                        imm: v227,
                                                                    } = &v200.1 {
                                                                        if let &Opcode::Iconst = v226 {
                                                                            let v229 = C::ty_mask(ctx, v2.0);
                                                                            let v16 = C::u64_from_imm64(ctx, v15);
                                                                            let v230 = C::u64_and(ctx, v229, v16);
                                                                            let v228 = C::u64_from_imm64(ctx, v227);
                                                                            let v231 = C::u64_not(ctx, v228);
                                                                            let v232 = C::u64_and(ctx, v229, v231);
                                                                            let v233 = C::u64_eq(ctx, v230, v232);
                                                                            if v233 == true {
                                                                                if v2.0 == v200.0 {
                                                                                    let v224 = constructor_bor(ctx, v2.0, v124.0, v7.1);
                                                                                    // Rule at src/opts/bitops.isle line 69.
                                                                                    returns.extend(Some(v224));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &Opcode::Bor => {
                                                            if v2.0 == v19.0 {
                                                                let v124 = C::unpack_value_array_2(ctx, v123);
                                                                let mut v199 = C::inst_data_etor_returns::default();
                                                                C::inst_data_etor(ctx, v124.1, &mut v199);
                                                                let mut v199 = v199.into_context_iter();
                                                                while let Some(v200) = v199.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v226,
                                                                        imm: v227,
                                                                    } = &v200.1 {
                                                                        if let &Opcode::Iconst = v226 {
                                                                            if v2.0 == v200.0 {
                                                                                let v635 = constructor_bor(ctx, v2.0, v124.1, v7.1);
                                                                                let v636 = constructor_bor(ctx, v2.0, v124.0, v635);
                                                                                // Rule at src/opts/cprop.isle line 159.
                                                                                returns.extend(Some(v636));
                                                                                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 v526 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v527) = v526 {
                                            if v11.0 == v527 {
                                                let mut v18 = C::inst_data_etor_returns::default();
                                                C::inst_data_etor(ctx, v7.0, &mut v18);
                                                let mut v18 = v18.into_context_iter();
                                                while let Some(v19) = v18.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v22,
                                                        imm: v23,
                                                    } = &v19.1 {
                                                        if let &Opcode::Iconst = v22 {
                                                            if v11.0 == v19.0 {
                                                                let v24 = C::u64_from_imm64(ctx, v23);
                                                                let v16 = C::u64_from_imm64(ctx, v15);
                                                                let v550 = C::u64_or(ctx, v24, v16);
                                                                let v551 = C::imm64_masked(ctx, v527, v550);
                                                                let v552 = constructor_iconst(ctx, v527, v551);
                                                                let v553 = C::subsume(ctx, v552);
                                                                // Rule at src/opts/cprop.isle line 34.
                                                                returns.extend(Some(v553));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        let v1077 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 17.
                                        returns.extend(Some(v1077));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                _ => {}
                            }
                        }
                        let mut v18 = C::inst_data_etor_returns::default();
                        C::inst_data_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::Bnot = v29 {
                                        if v7.1 == v30 {
                                            let v52 = C::ty_int(ctx, v2.0);
                                            if let Some(v53) = v52 {
                                                if v19.0 == v53 {
                                                    let v218 = constructor_iconst_s(ctx, v53, -1_i64);
                                                    let v219 = C::subsume(ctx, v218);
                                                    // Rule at src/opts/bitops.isle line 25.
                                                    returns.extend(Some(v219));
                                                    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 v606 = constructor_bor(ctx, v2.0, v7.1, v7.0);
                                            // Rule at src/opts/cprop.isle line 106.
                                            returns.extend(Some(v606));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        let v1077 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 15.
                                        returns.extend(Some(v1077));
                                        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_etor_returns::default();
                        C::inst_data_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 v104,
                                    args: ref v105,
                                } => {
                                    if let &Opcode::Bxor = v104 {
                                        if v2.0 == v11.0 {
                                            let v106 = C::unpack_value_array_2(ctx, v105);
                                            let mut v109 = C::inst_data_etor_returns::default();
                                            C::inst_data_etor(ctx, v106.1, &mut v109);
                                            let mut v109 = v109.into_context_iter();
                                            while let Some(v110) = v109.next(ctx) {
                                                match &v110.1 {
                                                    &InstructionData::Binary {
                                                        opcode: ref v113,
                                                        args: ref v114,
                                                    } => {
                                                        if let &Opcode::Bxor = v113 {
                                                            if v2.0 == v110.0 {
                                                                let v156 = constructor_bxor(ctx, v2.0, v7.0, v106.0);
                                                                let v115 = C::unpack_value_array_2(ctx, v114);
                                                                let v157 = constructor_bxor(ctx, v2.0, v115.0, v115.1);
                                                                let v158 = constructor_bxor(ctx, v2.0, v156, v157);
                                                                let v159 = C::subsume(ctx, v158);
                                                                // Rule at src/opts/arithmetic.isle line 149.
                                                                returns.extend(Some(v159));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                    &InstructionData::UnaryImm {
                                                        opcode: ref v686,
                                                        imm: v687,
                                                    } => {
                                                        if let &Opcode::Iconst = v686 {
                                                            let mut v18 = C::inst_data_etor_returns::default();
                                                            C::inst_data_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 v122,
                                                                    args: ref v123,
                                                                } = &v19.1 {
                                                                    if let &Opcode::Bxor = v122 {
                                                                        if v2.0 == v19.0 {
                                                                            let v124 = C::unpack_value_array_2(ctx, v123);
                                                                            let mut v199 = C::inst_data_etor_returns::default();
                                                                            C::inst_data_etor(ctx, v124.1, &mut v199);
                                                                            let mut v199 = v199.into_context_iter();
                                                                            while let Some(v200) = v199.next(ctx) {
                                                                                if let &InstructionData::UnaryImm {
                                                                                    opcode: ref v226,
                                                                                    imm: v227,
                                                                                } = &v200.1 {
                                                                                    if let &Opcode::Iconst = v226 {
                                                                                        let v700 = constructor_bxor(ctx, v2.0, v124.0, v106.0);
                                                                                        let v701 = constructor_bxor(ctx, v2.0, v124.1, v106.1);
                                                                                        let v702 = constructor_bxor(ctx, v2.0, v700, v701);
                                                                                        // Rule at src/opts/cprop.isle line 240.
                                                                                        returns.extend(Some(v702));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                    _ => {}
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v26,
                                    arg: v27,
                                } => {
                                    match v26 {
                                        &Opcode::Splat => {
                                            let v1313 = C::ty_vector_not_float(ctx, v2.0);
                                            if let Some(v1314) = v1313 {
                                                if v2.0 == v11.0 {
                                                    let mut v18 = C::inst_data_etor_returns::default();
                                                    C::inst_data_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 v1186 = C::lane_type(ctx, v2.0);
                                                                    let v1319 = constructor_bxor(ctx, v1186, v30, v27);
                                                                    let v1320 = constructor_splat(ctx, v2.0, v1319);
                                                                    // Rule at src/opts/vector.isle line 22.
                                                                    returns.extend(Some(v1320));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Bnot => {
                                            let v52 = C::ty_int(ctx, v2.0);
                                            if let Some(v53) = v52 {
                                                if v7.0 == v27 {
                                                    if v11.0 == v53 {
                                                        let v218 = constructor_iconst_s(ctx, v53, -1_i64);
                                                        let v219 = C::subsume(ctx, v218);
                                                        // Rule at src/opts/bitops.isle line 22.
                                                        returns.extend(Some(v219));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Uextend => {
                                            let mut v18 = C::inst_data_etor_returns::default();
                                            C::inst_data_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 v901 = C::value_type(ctx, v30);
                                                        let v936 = C::value_type(ctx, v27);
                                                        if v901 == v936 {
                                                            let v941 = constructor_bxor(ctx, v901, v30, v27);
                                                            let v942 = constructor_uextend(ctx, v2.0, v941);
                                                            // Rule at src/opts/extends.isle line 74.
                                                            returns.extend(Some(v942));
                                                            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_etor_returns::default();
                                            C::inst_data_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 v122,
                                                    args: ref v123,
                                                } = &v19.1 {
                                                    if let &Opcode::Bxor = v122 {
                                                        if v2.0 == v19.0 {
                                                            let v124 = C::unpack_value_array_2(ctx, v123);
                                                            let mut v199 = C::inst_data_etor_returns::default();
                                                            C::inst_data_etor(ctx, v124.1, &mut v199);
                                                            let mut v199 = v199.into_context_iter();
                                                            while let Some(v200) = v199.next(ctx) {
                                                                if let &InstructionData::UnaryImm {
                                                                    opcode: ref v226,
                                                                    imm: v227,
                                                                } = &v200.1 {
                                                                    if let &Opcode::Iconst = v226 {
                                                                        if v2.0 == v200.0 {
                                                                            let v639 = constructor_bxor(ctx, v2.0, v124.1, v7.1);
                                                                            let v640 = constructor_bxor(ctx, v2.0, v124.0, v639);
                                                                            // Rule at src/opts/cprop.isle line 165.
                                                                            returns.extend(Some(v640));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        let v526 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v527) = v526 {
                                            if v11.0 == v527 {
                                                let mut v18 = C::inst_data_etor_returns::default();
                                                C::inst_data_etor(ctx, v7.0, &mut v18);
                                                let mut v18 = v18.into_context_iter();
                                                while let Some(v19) = v18.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v22,
                                                        imm: v23,
                                                    } = &v19.1 {
                                                        if let &Opcode::Iconst = v22 {
                                                            if v11.0 == v19.0 {
                                                                let v24 = C::u64_from_imm64(ctx, v23);
                                                                let v16 = C::u64_from_imm64(ctx, v15);
                                                                let v558 = C::u64_xor(ctx, v24, v16);
                                                                let v559 = C::imm64_masked(ctx, v527, v558);
                                                                let v560 = constructor_iconst(ctx, v527, v559);
                                                                let v561 = C::subsume(ctx, v560);
                                                                // Rule at src/opts/cprop.isle line 46.
                                                                returns.extend(Some(v561));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        let v1077 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 21.
                                        returns.extend(Some(v1077));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                _ => {}
                            }
                        }
                        let mut v18 = C::inst_data_etor_returns::default();
                        C::inst_data_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 v122,
                                    args: ref v123,
                                } => {
                                    if let &Opcode::Bxor = v122 {
                                        if v2.0 == v19.0 {
                                            let v124 = C::unpack_value_array_2(ctx, v123);
                                            let mut v127 = C::inst_data_etor_returns::default();
                                            C::inst_data_etor(ctx, v124.0, &mut v127);
                                            let mut v127 = v127.into_context_iter();
                                            while let Some(v128) = v127.next(ctx) {
                                                if let &InstructionData::Binary {
                                                    opcode: ref v131,
                                                    args: ref v132,
                                                } = &v128.1 {
                                                    if let &Opcode::Bxor = v131 {
                                                        if v2.0 == v128.0 {
                                                            let v133 = C::unpack_value_array_2(ctx, v132);
                                                            let v160 = constructor_bxor(ctx, v2.0, v133.0, v133.1);
                                                            let v161 = constructor_bxor(ctx, v2.0, v124.1, v7.1);
                                                            let v162 = constructor_bxor(ctx, v2.0, v160, v161);
                                                            let v163 = C::subsume(ctx, v162);
                                                            // Rule at src/opts/arithmetic.isle line 151.
                                                            returns.extend(Some(v163));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v29,
                                    arg: v30,
                                } => {
                                    if let &Opcode::Bnot = v29 {
                                        if v7.1 == v30 {
                                            let v52 = C::ty_int(ctx, v2.0);
                                            if let Some(v53) = v52 {
                                                if v19.0 == v53 {
                                                    let v218 = constructor_iconst_s(ctx, v53, -1_i64);
                                                    let v219 = C::subsume(ctx, v218);
                                                    // Rule at src/opts/bitops.isle line 23.
                                                    returns.extend(Some(v219));
                                                    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 v608 = constructor_bxor(ctx, v2.0, v7.1, v7.0);
                                            // Rule at src/opts/cprop.isle line 112.
                                            returns.extend(Some(v608));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        let v1077 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 19.
                                        returns.extend(Some(v1077));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                _ => {}
                            }
                        }
                        if v7.0 == v7.1 {
                            let v52 = C::ty_int(ctx, v2.0);
                            if let Some(v53) = v52 {
                                let v55 = constructor_iconst_u(ctx, v53, 0x0_u64);
                                let v56 = C::subsume(ctx, v55);
                                // Rule at src/opts/bitops.isle line 17.
                                returns.extend(Some(v56));
                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                            }
                        }
                        let mut v58 = C::inst_data_tupled_etor_returns::default();
                        C::inst_data_tupled_etor(ctx, v7.1, &mut v58);
                        let mut v58 = v58.into_context_iter();
                        while let Some(v59) = v58.next(ctx) {
                            let v60 = C::iconst_sextend_etor(ctx, v59);
                            if let Some(v61) = v60 {
                                if v61.1 == -1_i64 {
                                    if v2.0 == v61.0 {
                                        let v234 = constructor_bnot(ctx, v2.0, v7.0);
                                        // Rule at src/opts/bitops.isle line 77.
                                        returns.extend(Some(v234));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                            }
                        }
                    }
                    &Opcode::Rotl => {
                        let v7 = C::unpack_value_array_2(ctx, v6);
                        let mut v10 = C::inst_data_etor_returns::default();
                        C::inst_data_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 v104,
                                    args: ref v105,
                                } => {
                                    if let &Opcode::Iconcat = v104 {
                                        let v106 = C::unpack_value_array_2(ctx, v105);
                                        let v1182 = constructor_rotl(ctx, v2.0, v7.0, v106.0);
                                        // Rule at src/opts/shifts.isle line 142.
                                        returns.extend(Some(v1182));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v26,
                                    arg: v27,
                                } => {
                                    match v26 {
                                        &Opcode::Ireduce => {
                                            let v936 = C::value_type(ctx, v27);
                                            let v1171 = C::fits_in_64(ctx, v936);
                                            if let Some(v1172) = v1171 {
                                                let v1177 = constructor_rotl(ctx, v2.0, v7.0, v27);
                                                // Rule at src/opts/shifts.isle line 126.
                                                returns.extend(Some(v1177));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        &Opcode::Uextend => {
                                            let v1177 = constructor_rotl(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 127.
                                            returns.extend(Some(v1177));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Sextend => {
                                            let v1177 = constructor_rotl(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 128.
                                            returns.extend(Some(v1177));
                                            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_etor_returns::default();
                                        C::inst_data_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 v122,
                                                args: ref v123,
                                            } = &v19.1 {
                                                match v122 {
                                                    &Opcode::Rotl => {
                                                        if v2.0 == v19.0 {
                                                            let v124 = C::unpack_value_array_2(ctx, v123);
                                                            let v1195 = constructor_iadd_uextend(ctx, v124.1, v7.1);
                                                            let v1196 = constructor_rotl(ctx, v2.0, v124.0, v1195);
                                                            // Rule at src/opts/shifts.isle line 239.
                                                            returns.extend(Some(v1196));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                    &Opcode::Rotr => {
                                                        if v2.0 == v19.0 {
                                                            let v124 = C::unpack_value_array_2(ctx, v123);
                                                            let v1198 = constructor_isub_uextend(ctx, v124.1, v7.1);
                                                            let v1200 = constructor_rotr(ctx, v2.0, v124.0, v1198);
                                                            // Rule at src/opts/shifts.isle line 246.
                                                            returns.extend(Some(v1200));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                    _ => {}
                                                }
                                            }
                                        }
                                        let v16 = C::u64_from_imm64(ctx, v15);
                                        if v16 == 0x0_u64 {
                                            if v2.0 == v11.0 {
                                                let v17 = C::subsume(ctx, v7.0);
                                                // Rule at src/opts/shifts.isle line 19.
                                                returns.extend(Some(v17));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        let v235 = constructor_ty_shift_mask(ctx, v2.0);
                                        let v1184 = C::u64_and(ctx, v16, v235);
                                        let v1211 = C::u64_eq(ctx, v16, v1184);
                                        if v1211 == false {
                                            let v1212 = constructor_iconst_u(ctx, v11.0, v1184);
                                            let v1217 = constructor_rotl(ctx, v2.0, v7.0, v1212);
                                            // Rule at src/opts/shifts.isle line 304.
                                            returns.extend(Some(v1217));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                        let mut v18 = C::inst_data_etor_returns::default();
                        C::inst_data_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 v122,
                                    args: ref v123,
                                } => {
                                    match v122 {
                                        &Opcode::Rotl => {
                                            if v2.0 == v19.0 {
                                                let v124 = C::unpack_value_array_2(ctx, v123);
                                                let v1201 = C::value_type(ctx, v124.1);
                                                let v1202 = C::value_type(ctx, v7.1);
                                                if v1201 == v1202 {
                                                    let v1195 = constructor_iadd_uextend(ctx, v124.1, v7.1);
                                                    let v1196 = constructor_rotl(ctx, v2.0, v124.0, v1195);
                                                    // Rule at src/opts/shifts.isle line 260.
                                                    returns.extend(Some(v1196));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let mut v199 = C::inst_data_etor_returns::default();
                                                C::inst_data_etor(ctx, v124.1, &mut v199);
                                                let mut v199 = v199.into_context_iter();
                                                while let Some(v200) = v199.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v226,
                                                        imm: v227,
                                                    } = &v200.1 {
                                                        if let &Opcode::Iconst = v226 {
                                                            let v1195 = constructor_iadd_uextend(ctx, v124.1, v7.1);
                                                            let v1196 = constructor_rotl(ctx, v2.0, v124.0, v1195);
                                                            // Rule at src/opts/shifts.isle line 238.
                                                            returns.extend(Some(v1196));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Rotr => {
                                            if v2.0 == v19.0 {
                                                let v124 = C::unpack_value_array_2(ctx, v123);
                                                if v7.1 == v124.1 {
                                                    let v1194 = C::subsume(ctx, v124.0);
                                                    // Rule at src/opts/shifts.isle line 203.
                                                    returns.extend(Some(v1194));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let v1201 = C::value_type(ctx, v124.1);
                                                let v1202 = C::value_type(ctx, v7.1);
                                                if v1201 == v1202 {
                                                    let v1198 = constructor_isub_uextend(ctx, v124.1, v7.1);
                                                    let v1200 = constructor_rotr(ctx, v2.0, v124.0, v1198);
                                                    // Rule at src/opts/shifts.isle line 265.
                                                    returns.extend(Some(v1200));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let mut v199 = C::inst_data_etor_returns::default();
                                                C::inst_data_etor(ctx, v124.1, &mut v199);
                                                let mut v199 = v199.into_context_iter();
                                                while let Some(v200) = v199.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v226,
                                                        imm: v227,
                                                    } = &v200.1 {
                                                        if let &Opcode::Iconst = v226 {
                                                            let v1198 = constructor_isub_uextend(ctx, v124.1, v7.1);
                                                            let v1200 = constructor_rotr(ctx, v2.0, v124.0, v1198);
                                                            // Rule at src/opts/shifts.isle line 245.
                                                            returns.extend(Some(v1200));
                                                            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 v1186 = C::lane_type(ctx, v2.0);
                                            let v1347 = constructor_rotl(ctx, v1186, v30, v7.1);
                                            let v1348 = constructor_splat(ctx, v2.0, v1347);
                                            // Rule at src/opts/vector.isle line 68.
                                            returns.extend(Some(v1348));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                    }
                    &Opcode::Rotr => {
                        let v7 = C::unpack_value_array_2(ctx, v6);
                        let mut v10 = C::inst_data_etor_returns::default();
                        C::inst_data_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 v104,
                                    args: ref v105,
                                } => {
                                    if let &Opcode::Iconcat = v104 {
                                        let v106 = C::unpack_value_array_2(ctx, v105);
                                        let v1181 = constructor_rotr(ctx, v2.0, v7.0, v106.0);
                                        // Rule at src/opts/shifts.isle line 141.
                                        returns.extend(Some(v1181));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v26,
                                    arg: v27,
                                } => {
                                    match v26 {
                                        &Opcode::Ireduce => {
                                            let v936 = C::value_type(ctx, v27);
                                            let v1171 = C::fits_in_64(ctx, v936);
                                            if let Some(v1172) = v1171 {
                                                let v1176 = constructor_rotr(ctx, v2.0, v7.0, v27);
                                                // Rule at src/opts/shifts.isle line 123.
                                                returns.extend(Some(v1176));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        &Opcode::Uextend => {
                                            let v1176 = constructor_rotr(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 124.
                                            returns.extend(Some(v1176));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Sextend => {
                                            let v1176 = constructor_rotr(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 125.
                                            returns.extend(Some(v1176));
                                            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_etor_returns::default();
                                        C::inst_data_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 v122,
                                                args: ref v123,
                                            } = &v19.1 {
                                                match v122 {
                                                    &Opcode::Rotl => {
                                                        if v2.0 == v19.0 {
                                                            let v124 = C::unpack_value_array_2(ctx, v123);
                                                            let v1198 = constructor_isub_uextend(ctx, v124.1, v7.1);
                                                            let v1199 = constructor_rotl(ctx, v2.0, v124.0, v1198);
                                                            // Rule at src/opts/shifts.isle line 244.
                                                            returns.extend(Some(v1199));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                    &Opcode::Rotr => {
                                                        if v2.0 == v19.0 {
                                                            let v124 = C::unpack_value_array_2(ctx, v123);
                                                            let v1195 = constructor_iadd_uextend(ctx, v124.1, v7.1);
                                                            let v1197 = constructor_rotr(ctx, v2.0, v124.0, v1195);
                                                            // Rule at src/opts/shifts.isle line 241.
                                                            returns.extend(Some(v1197));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                    _ => {}
                                                }
                                            }
                                        }
                                        let v16 = C::u64_from_imm64(ctx, v15);
                                        if v16 == 0x0_u64 {
                                            if v2.0 == v11.0 {
                                                let v17 = C::subsume(ctx, v7.0);
                                                // Rule at src/opts/shifts.isle line 15.
                                                returns.extend(Some(v17));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        let v235 = constructor_ty_shift_mask(ctx, v2.0);
                                        let v1184 = C::u64_and(ctx, v16, v235);
                                        let v1211 = C::u64_eq(ctx, v16, v1184);
                                        if v1211 == false {
                                            let v1212 = constructor_iconst_u(ctx, v11.0, v1184);
                                            let v1216 = constructor_rotr(ctx, v2.0, v7.0, v1212);
                                            // Rule at src/opts/shifts.isle line 301.
                                            returns.extend(Some(v1216));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                        let mut v18 = C::inst_data_etor_returns::default();
                        C::inst_data_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 v122,
                                    args: ref v123,
                                } => {
                                    match v122 {
                                        &Opcode::Rotl => {
                                            if v2.0 == v19.0 {
                                                let v124 = C::unpack_value_array_2(ctx, v123);
                                                if v7.1 == v124.1 {
                                                    let v1194 = C::subsume(ctx, v124.0);
                                                    // Rule at src/opts/shifts.isle line 204.
                                                    returns.extend(Some(v1194));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let v1201 = C::value_type(ctx, v124.1);
                                                let v1202 = C::value_type(ctx, v7.1);
                                                if v1201 == v1202 {
                                                    let v1198 = constructor_isub_uextend(ctx, v124.1, v7.1);
                                                    let v1199 = constructor_rotl(ctx, v2.0, v124.0, v1198);
                                                    // Rule at src/opts/shifts.isle line 263.
                                                    returns.extend(Some(v1199));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let mut v199 = C::inst_data_etor_returns::default();
                                                C::inst_data_etor(ctx, v124.1, &mut v199);
                                                let mut v199 = v199.into_context_iter();
                                                while let Some(v200) = v199.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v226,
                                                        imm: v227,
                                                    } = &v200.1 {
                                                        if let &Opcode::Iconst = v226 {
                                                            let v1198 = constructor_isub_uextend(ctx, v124.1, v7.1);
                                                            let v1199 = constructor_rotl(ctx, v2.0, v124.0, v1198);
                                                            // Rule at src/opts/shifts.isle line 243.
                                                            returns.extend(Some(v1199));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Rotr => {
                                            if v2.0 == v19.0 {
                                                let v124 = C::unpack_value_array_2(ctx, v123);
                                                let v1201 = C::value_type(ctx, v124.1);
                                                let v1202 = C::value_type(ctx, v7.1);
                                                if v1201 == v1202 {
                                                    let v1195 = constructor_iadd_uextend(ctx, v124.1, v7.1);
                                                    let v1197 = constructor_rotr(ctx, v2.0, v124.0, v1195);
                                                    // Rule at src/opts/shifts.isle line 258.
                                                    returns.extend(Some(v1197));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let mut v199 = C::inst_data_etor_returns::default();
                                                C::inst_data_etor(ctx, v124.1, &mut v199);
                                                let mut v199 = v199.into_context_iter();
                                                while let Some(v200) = v199.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v226,
                                                        imm: v227,
                                                    } = &v200.1 {
                                                        if let &Opcode::Iconst = v226 {
                                                            let v1195 = constructor_iadd_uextend(ctx, v124.1, v7.1);
                                                            let v1197 = constructor_rotr(ctx, v2.0, v124.0, v1195);
                                                            // Rule at src/opts/shifts.isle line 240.
                                                            returns.extend(Some(v1197));
                                                            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 v1186 = C::lane_type(ctx, v2.0);
                                            let v1349 = constructor_rotr(ctx, v1186, v30, v7.1);
                                            let v1350 = constructor_splat(ctx, v2.0, v1349);
                                            // Rule at src/opts/vector.isle line 71.
                                            returns.extend(Some(v1350));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                    }
                    &Opcode::Ishl => {
                        let v7 = C::unpack_value_array_2(ctx, v6);
                        let mut v10 = C::inst_data_etor_returns::default();
                        C::inst_data_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 v104,
                                    args: ref v105,
                                } => {
                                    if let &Opcode::Iconcat = v104 {
                                        let v106 = C::unpack_value_array_2(ctx, v105);
                                        let v1178 = constructor_ishl(ctx, v2.0, v7.0, v106.0);
                                        // Rule at src/opts/shifts.isle line 138.
                                        returns.extend(Some(v1178));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v26,
                                    arg: v27,
                                } => {
                                    match v26 {
                                        &Opcode::Ireduce => {
                                            let v936 = C::value_type(ctx, v27);
                                            let v1171 = C::fits_in_64(ctx, v936);
                                            if let Some(v1172) = v1171 {
                                                let v1173 = constructor_ishl(ctx, v2.0, v7.0, v27);
                                                // Rule at src/opts/shifts.isle line 114.
                                                returns.extend(Some(v1173));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        &Opcode::Uextend => {
                                            let v1173 = constructor_ishl(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 115.
                                            returns.extend(Some(v1173));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Sextend => {
                                            let v1173 = constructor_ishl(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 116.
                                            returns.extend(Some(v1173));
                                            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_etor_returns::default();
                                        C::inst_data_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 v122,
                                                    args: ref v123,
                                                } => {
                                                    match v122 {
                                                        &Opcode::Ishl => {
                                                            if v2.0 == v19.0 {
                                                                let v124 = C::unpack_value_array_2(ctx, v123);
                                                                let mut v199 = C::inst_data_etor_returns::default();
                                                                C::inst_data_etor(ctx, v124.1, &mut v199);
                                                                let mut v199 = v199.into_context_iter();
                                                                while let Some(v200) = v199.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v226,
                                                                        imm: v227,
                                                                    } = &v200.1 {
                                                                        if let &Opcode::Iconst = v226 {
                                                                            let v228 = C::u64_from_imm64(ctx, v227);
                                                                            let v235 = constructor_ty_shift_mask(ctx, v2.0);
                                                                            let v1183 = C::u64_and(ctx, v228, v235);
                                                                            let v16 = C::u64_from_imm64(ctx, v15);
                                                                            let v1184 = C::u64_and(ctx, v16, v235);
                                                                            let v1185 = C::u64_add(ctx, v1183, v1184);
                                                                            let v1186 = C::lane_type(ctx, v2.0);
                                                                            let v1187 = C::ty_bits_u64(ctx, v1186);
                                                                            let v1188 = C::u64_lt(ctx, v1185, v1187);
                                                                            if v1188 == true {
                                                                                let v1189 = constructor_iconst_u(ctx, v200.0, v1185);
                                                                                let v1190 = constructor_ishl(ctx, v2.0, v124.0, v1189);
                                                                                // Rule at src/opts/shifts.isle line 151.
                                                                                returns.extend(Some(v1190));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                            let v1147 = C::ty_bits_u64(ctx, v2.0);
                                                                            let v1193 = C::u64_le(ctx, v1147, v1185);
                                                                            if v1193 == true {
                                                                                let v910 = constructor_iconst_u(ctx, v2.0, 0x0_u64);
                                                                                let v911 = C::subsume(ctx, v910);
                                                                                // Rule at src/opts/shifts.isle line 183.
                                                                                returns.extend(Some(v911));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                let mut v127 = C::inst_data_etor_returns::default();
                                                                C::inst_data_etor(ctx, v124.0, &mut v127);
                                                                let mut v127 = v127.into_context_iter();
                                                                while let Some(v128) = v127.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v617,
                                                                        imm: v618,
                                                                    } = &v128.1 {
                                                                        if let &Opcode::Iconst = v617 {
                                                                            let v680 = constructor_ishl(ctx, v2.0, v124.0, v7.1);
                                                                            let v681 = constructor_ishl(ctx, v2.0, v680, v124.1);
                                                                            // Rule at src/opts/cprop.isle line 211.
                                                                            returns.extend(Some(v681));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &Opcode::Ushr => {
                                                            let v526 = C::fits_in_64(ctx, v2.0);
                                                            if let Some(v527) = v526 {
                                                                if v19.0 == v527 {
                                                                    let v124 = C::unpack_value_array_2(ctx, v123);
                                                                    let mut v199 = C::inst_data_etor_returns::default();
                                                                    C::inst_data_etor(ctx, v124.1, &mut v199);
                                                                    let mut v199 = v199.into_context_iter();
                                                                    while let Some(v200) = v199.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v226,
                                                                            imm: v227,
                                                                        } = &v200.1 {
                                                                            if let &Opcode::Iconst = v226 {
                                                                                if v15 == v227 {
                                                                                    let v1138 = C::imm64(ctx, 0xffffffffffffffff_u64);
                                                                                    let v1139 = C::imm64_shl(ctx, v527, v1138, v227);
                                                                                    let v1140 = constructor_iconst(ctx, v527, v1139);
                                                                                    let v1141 = constructor_band(ctx, v527, v124.0, v1140);
                                                                                    // Rule at src/opts/shifts.isle line 26.
                                                                                    returns.extend(Some(v1141));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &Opcode::Sshr => {
                                                            let v526 = C::fits_in_64(ctx, v2.0);
                                                            if let Some(v527) = v526 {
                                                                if v19.0 == v527 {
                                                                    let v124 = C::unpack_value_array_2(ctx, v123);
                                                                    let mut v199 = C::inst_data_etor_returns::default();
                                                                    C::inst_data_etor(ctx, v124.1, &mut v199);
                                                                    let mut v199 = v199.into_context_iter();
                                                                    while let Some(v200) = v199.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v226,
                                                                            imm: v227,
                                                                        } = &v200.1 {
                                                                            if let &Opcode::Iconst = v226 {
                                                                                if v15 == v227 {
                                                                                    let v1138 = C::imm64(ctx, 0xffffffffffffffff_u64);
                                                                                    let v1139 = C::imm64_shl(ctx, v527, v1138, v227);
                                                                                    let v1140 = constructor_iconst(ctx, v527, v1139);
                                                                                    let v1141 = constructor_band(ctx, v527, v124.0, v1140);
                                                                                    // Rule at src/opts/shifts.isle line 31.
                                                                                    returns.extend(Some(v1141));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                &InstructionData::UnaryImm {
                                                    opcode: ref v22,
                                                    imm: v23,
                                                } => {
                                                    if let &Opcode::Iconst = v22 {
                                                        let v526 = C::fits_in_64(ctx, v2.0);
                                                        if let Some(v527) = v526 {
                                                            if v19.0 == v527 {
                                                                let v569 = C::imm64_shl(ctx, v527, v23, v15);
                                                                let v570 = constructor_iconst(ctx, v527, v569);
                                                                let v571 = C::subsume(ctx, v570);
                                                                // Rule at src/opts/cprop.isle line 57.
                                                                returns.extend(Some(v571));
                                                                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 v235 = constructor_ty_shift_mask(ctx, v2.0);
                                        let v1184 = C::u64_and(ctx, v16, v235);
                                        let v1211 = C::u64_eq(ctx, v16, v1184);
                                        if v1211 == false {
                                            let v1212 = constructor_iconst_u(ctx, v11.0, v1184);
                                            let v1213 = constructor_ishl(ctx, v2.0, v7.0, v1212);
                                            // Rule at src/opts/shifts.isle line 292.
                                            returns.extend(Some(v1213));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                        let mut v18 = C::inst_data_etor_returns::default();
                        C::inst_data_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 v1186 = C::lane_type(ctx, v2.0);
                                        let v1351 = constructor_ishl(ctx, v1186, v30, v7.1);
                                        let v1352 = constructor_splat(ctx, v2.0, v1351);
                                        // Rule at src/opts/vector.isle line 74.
                                        returns.extend(Some(v1352));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                            }
                        }
                    }
                    &Opcode::Ushr => {
                        let v7 = C::unpack_value_array_2(ctx, v6);
                        let mut v10 = C::inst_data_etor_returns::default();
                        C::inst_data_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 v104,
                                    args: ref v105,
                                } => {
                                    if let &Opcode::Iconcat = v104 {
                                        let v106 = C::unpack_value_array_2(ctx, v105);
                                        let v1179 = constructor_ushr(ctx, v2.0, v7.0, v106.0);
                                        // Rule at src/opts/shifts.isle line 139.
                                        returns.extend(Some(v1179));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v26,
                                    arg: v27,
                                } => {
                                    match v26 {
                                        &Opcode::Ireduce => {
                                            let v936 = C::value_type(ctx, v27);
                                            let v1171 = C::fits_in_64(ctx, v936);
                                            if let Some(v1172) = v1171 {
                                                let v1174 = constructor_ushr(ctx, v2.0, v7.0, v27);
                                                // Rule at src/opts/shifts.isle line 117.
                                                returns.extend(Some(v1174));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        &Opcode::Uextend => {
                                            let v1174 = constructor_ushr(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 118.
                                            returns.extend(Some(v1174));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Sextend => {
                                            let v1174 = constructor_ushr(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 119.
                                            returns.extend(Some(v1174));
                                            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_etor_returns::default();
                                        C::inst_data_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 v122,
                                                    args: ref v123,
                                                } => {
                                                    match v122 {
                                                        &Opcode::Imul => {
                                                            let v206 = C::ty_half_width(ctx, v2.0);
                                                            if let Some(v207) = v206 {
                                                                if v2.0 == v19.0 {
                                                                    let v124 = C::unpack_value_array_2(ctx, v123);
                                                                    let mut v127 = C::inst_data_etor_returns::default();
                                                                    C::inst_data_etor(ctx, v124.0, &mut v127);
                                                                    let mut v127 = v127.into_context_iter();
                                                                    while let Some(v128) = v127.next(ctx) {
                                                                        if let &InstructionData::Unary {
                                                                            opcode: ref v196,
                                                                            arg: v197,
                                                                        } = &v128.1 {
                                                                            if let &Opcode::Uextend = v196 {
                                                                                let v198 = C::value_type(ctx, v197);
                                                                                let v208 = C::ty_equal(ctx, v198, v207);
                                                                                if v208 == true {
                                                                                    let v16 = C::u64_from_imm64(ctx, v15);
                                                                                    let v209 = C::ty_bits_u64(ctx, v198);
                                                                                    let v210 = C::u64_eq(ctx, v16, v209);
                                                                                    if v210 == true {
                                                                                        let mut v199 = C::inst_data_etor_returns::default();
                                                                                        C::inst_data_etor(ctx, v124.1, &mut v199);
                                                                                        let mut v199 = v199.into_context_iter();
                                                                                        while let Some(v200) = v199.next(ctx) {
                                                                                            if let &InstructionData::Unary {
                                                                                                opcode: ref v203,
                                                                                                arg: v204,
                                                                                            } = &v200.1 {
                                                                                                if let &Opcode::Uextend = v203 {
                                                                                                    let v205 = C::value_type(ctx, v204);
                                                                                                    if v198 == v205 {
                                                                                                        let v213 = constructor_umulhi(ctx, v198, v197, v204);
                                                                                                        let v214 = constructor_uextend(ctx, v2.0, v213);
                                                                                                        // Rule at src/opts/arithmetic.isle line 224.
                                                                                                        returns.extend(Some(v214));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &Opcode::Ishl => {
                                                            let v124 = C::unpack_value_array_2(ctx, v123);
                                                            let mut v199 = C::inst_data_etor_returns::default();
                                                            C::inst_data_etor(ctx, v124.1, &mut v199);
                                                            let mut v199 = v199.into_context_iter();
                                                            while let Some(v200) = v199.next(ctx) {
                                                                if let &InstructionData::UnaryImm {
                                                                    opcode: ref v226,
                                                                    imm: v227,
                                                                } = &v200.1 {
                                                                    if let &Opcode::Iconst = v226 {
                                                                        if v15 == v227 {
                                                                            let v526 = C::fits_in_64(ctx, v2.0);
                                                                            if let Some(v527) = v526 {
                                                                                let v1005 = C::ty_int(ctx, v527);
                                                                                if let Some(v1006) = v1005 {
                                                                                    if v19.0 == v1006 {
                                                                                        let v1142 = C::ty_mask(ctx, v1006);
                                                                                        let v1143 = C::imm64(ctx, v1142);
                                                                                        let v1144 = C::imm64_ushr(ctx, v1006, v1143, v227);
                                                                                        let v1145 = constructor_iconst(ctx, v1006, v1144);
                                                                                        let v1146 = constructor_band(ctx, v1006, v124.0, v1145);
                                                                                        // Rule at src/opts/shifts.isle line 40.
                                                                                        returns.extend(Some(v1146));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                            let v228 = C::u64_from_imm64(ctx, v227);
                                                                            let v1153 = C::u64_is_zero(ctx, v228);
                                                                            if v1153 == false {
                                                                                let v1154 = C::ty_bits(ctx, v2.0);
                                                                                let v1155 = C::u8_as_u64(ctx, v1154);
                                                                                let v1156 = C::u64_sub(ctx, v1155, v228);
                                                                                let v1157 = constructor_shift_amt_to_type(ctx, v1156);
                                                                                if let Some(v1158) = v1157 {
                                                                                    if v2.0 == v19.0 {
                                                                                        let v1159 = constructor_ireduce(ctx, v1158, v124.0);
                                                                                        let v1161 = constructor_uextend(ctx, v2.0, v1159);
                                                                                        // Rule at src/opts/shifts.isle line 87.
                                                                                        returns.extend(Some(v1161));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &Opcode::Ushr => {
                                                            if v2.0 == v19.0 {
                                                                let v124 = C::unpack_value_array_2(ctx, v123);
                                                                let mut v199 = C::inst_data_etor_returns::default();
                                                                C::inst_data_etor(ctx, v124.1, &mut v199);
                                                                let mut v199 = v199.into_context_iter();
                                                                while let Some(v200) = v199.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v226,
                                                                        imm: v227,
                                                                    } = &v200.1 {
                                                                        if let &Opcode::Iconst = v226 {
                                                                            let v228 = C::u64_from_imm64(ctx, v227);
                                                                            let v235 = constructor_ty_shift_mask(ctx, v2.0);
                                                                            let v1183 = C::u64_and(ctx, v228, v235);
                                                                            let v16 = C::u64_from_imm64(ctx, v15);
                                                                            let v1184 = C::u64_and(ctx, v16, v235);
                                                                            let v1185 = C::u64_add(ctx, v1183, v1184);
                                                                            let v1186 = C::lane_type(ctx, v2.0);
                                                                            let v1187 = C::ty_bits_u64(ctx, v1186);
                                                                            let v1188 = C::u64_lt(ctx, v1185, v1187);
                                                                            if v1188 == true {
                                                                                let v1189 = constructor_iconst_u(ctx, v200.0, v1185);
                                                                                let v1191 = constructor_ushr(ctx, v2.0, v124.0, v1189);
                                                                                // Rule at src/opts/shifts.isle line 160.
                                                                                returns.extend(Some(v1191));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                            let v1147 = C::ty_bits_u64(ctx, v2.0);
                                                                            let v1193 = C::u64_le(ctx, v1147, v1185);
                                                                            if v1193 == true {
                                                                                let v910 = constructor_iconst_u(ctx, v2.0, 0x0_u64);
                                                                                let v911 = C::subsume(ctx, v910);
                                                                                // Rule at src/opts/shifts.isle line 192.
                                                                                returns.extend(Some(v911));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                let mut v127 = C::inst_data_etor_returns::default();
                                                                C::inst_data_etor(ctx, v124.0, &mut v127);
                                                                let mut v127 = v127.into_context_iter();
                                                                while let Some(v128) = v127.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v617,
                                                                        imm: v618,
                                                                    } = &v128.1 {
                                                                        if let &Opcode::Iconst = v617 {
                                                                            let v682 = constructor_ushr(ctx, v2.0, v124.0, v7.1);
                                                                            let v683 = constructor_ushr(ctx, v2.0, v682, v124.1);
                                                                            // Rule at src/opts/cprop.isle line 213.
                                                                            returns.extend(Some(v683));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                &InstructionData::UnaryImm {
                                                    opcode: ref v22,
                                                    imm: v23,
                                                } => {
                                                    if let &Opcode::Iconst = v22 {
                                                        let v526 = C::fits_in_64(ctx, v2.0);
                                                        if let Some(v527) = v526 {
                                                            if v19.0 == v527 {
                                                                let v572 = C::imm64_ushr(ctx, v527, v23, v15);
                                                                let v573 = constructor_iconst(ctx, v527, v572);
                                                                let v574 = C::subsume(ctx, v573);
                                                                // Rule at src/opts/cprop.isle line 62.
                                                                returns.extend(Some(v574));
                                                                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 v235 = constructor_ty_shift_mask(ctx, v2.0);
                                        let v1184 = C::u64_and(ctx, v16, v235);
                                        let v1211 = C::u64_eq(ctx, v16, v1184);
                                        if v1211 == false {
                                            let v1212 = constructor_iconst_u(ctx, v11.0, v1184);
                                            let v1214 = constructor_ushr(ctx, v2.0, v7.0, v1212);
                                            // Rule at src/opts/shifts.isle line 295.
                                            returns.extend(Some(v1214));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                        let mut v18 = C::inst_data_etor_returns::default();
                        C::inst_data_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 v1186 = C::lane_type(ctx, v2.0);
                                        let v1353 = constructor_ushr(ctx, v1186, v30, v7.1);
                                        let v1354 = constructor_splat(ctx, v2.0, v1353);
                                        // Rule at src/opts/vector.isle line 77.
                                        returns.extend(Some(v1354));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                            }
                        }
                    }
                    &Opcode::Sshr => {
                        let v7 = C::unpack_value_array_2(ctx, v6);
                        let mut v10 = C::inst_data_etor_returns::default();
                        C::inst_data_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 v104,
                                    args: ref v105,
                                } => {
                                    if let &Opcode::Iconcat = v104 {
                                        let v106 = C::unpack_value_array_2(ctx, v105);
                                        let v1180 = constructor_sshr(ctx, v2.0, v7.0, v106.0);
                                        // Rule at src/opts/shifts.isle line 140.
                                        returns.extend(Some(v1180));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v26,
                                    arg: v27,
                                } => {
                                    match v26 {
                                        &Opcode::Ireduce => {
                                            let v936 = C::value_type(ctx, v27);
                                            let v1171 = C::fits_in_64(ctx, v936);
                                            if let Some(v1172) = v1171 {
                                                let v1175 = constructor_sshr(ctx, v2.0, v7.0, v27);
                                                // Rule at src/opts/shifts.isle line 120.
                                                returns.extend(Some(v1175));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        &Opcode::Uextend => {
                                            let v1175 = constructor_sshr(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 121.
                                            returns.extend(Some(v1175));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Sextend => {
                                            let v1175 = constructor_sshr(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 122.
                                            returns.extend(Some(v1175));
                                            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_etor_returns::default();
                                        C::inst_data_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 v122,
                                                    args: ref v123,
                                                } => {
                                                    match v122 {
                                                        &Opcode::Imul => {
                                                            let v206 = C::ty_half_width(ctx, v2.0);
                                                            if let Some(v207) = v206 {
                                                                if v2.0 == v19.0 {
                                                                    let v124 = C::unpack_value_array_2(ctx, v123);
                                                                    let mut v127 = C::inst_data_etor_returns::default();
                                                                    C::inst_data_etor(ctx, v124.0, &mut v127);
                                                                    let mut v127 = v127.into_context_iter();
                                                                    while let Some(v128) = v127.next(ctx) {
                                                                        if let &InstructionData::Unary {
                                                                            opcode: ref v196,
                                                                            arg: v197,
                                                                        } = &v128.1 {
                                                                            if let &Opcode::Sextend = v196 {
                                                                                let v198 = C::value_type(ctx, v197);
                                                                                let v208 = C::ty_equal(ctx, v198, v207);
                                                                                if v208 == true {
                                                                                    let v16 = C::u64_from_imm64(ctx, v15);
                                                                                    let v209 = C::ty_bits_u64(ctx, v198);
                                                                                    let v210 = C::u64_eq(ctx, v16, v209);
                                                                                    if v210 == true {
                                                                                        let mut v199 = C::inst_data_etor_returns::default();
                                                                                        C::inst_data_etor(ctx, v124.1, &mut v199);
                                                                                        let mut v199 = v199.into_context_iter();
                                                                                        while let Some(v200) = v199.next(ctx) {
                                                                                            if let &InstructionData::Unary {
                                                                                                opcode: ref v203,
                                                                                                arg: v204,
                                                                                            } = &v200.1 {
                                                                                                if let &Opcode::Sextend = v203 {
                                                                                                    let v205 = C::value_type(ctx, v204);
                                                                                                    if v198 == v205 {
                                                                                                        let v211 = constructor_smulhi(ctx, v198, v197, v204);
                                                                                                        let v212 = constructor_sextend(ctx, v2.0, v211);
                                                                                                        // Rule at src/opts/arithmetic.isle line 218.
                                                                                                        returns.extend(Some(v212));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &Opcode::Bor => {
                                                            let v16 = C::u64_from_imm64(ctx, v15);
                                                            let v235 = constructor_ty_shift_mask(ctx, v2.0);
                                                            let v236 = C::u64_eq(ctx, v16, v235);
                                                            if v236 == true {
                                                                if v2.0 == v11.0 {
                                                                    if v2.0 == v19.0 {
                                                                        let v124 = C::unpack_value_array_2(ctx, v123);
                                                                        let mut v127 = C::inst_data_etor_returns::default();
                                                                        C::inst_data_etor(ctx, v124.0, &mut v127);
                                                                        let mut v127 = v127.into_context_iter();
                                                                        while let Some(v128) = v127.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v196,
                                                                                arg: v197,
                                                                            } = &v128.1 {
                                                                                if let &Opcode::Ineg = v196 {
                                                                                    if v2.0 == v128.0 {
                                                                                        if v124.1 == v197 {
                                                                                            let v238 = constructor_bmask(ctx, v2.0, v197);
                                                                                            // Rule at src/opts/bitops.isle line 88.
                                                                                            returns.extend(Some(v238));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let mut v199 = C::inst_data_etor_returns::default();
                                                                        C::inst_data_etor(ctx, v124.1, &mut v199);
                                                                        let mut v199 = v199.into_context_iter();
                                                                        while let Some(v200) = v199.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v203,
                                                                                arg: v204,
                                                                            } = &v200.1 {
                                                                                if let &Opcode::Ineg = v203 {
                                                                                    if v124.0 == v204 {
                                                                                        if v2.0 == v200.0 {
                                                                                            let v237 = constructor_bmask(ctx, v2.0, v124.0);
                                                                                            // Rule at src/opts/bitops.isle line 84.
                                                                                            returns.extend(Some(v237));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &Opcode::Ishl => {
                                                            if v2.0 == v19.0 {
                                                                let v124 = C::unpack_value_array_2(ctx, v123);
                                                                let mut v199 = C::inst_data_etor_returns::default();
                                                                C::inst_data_etor(ctx, v124.1, &mut v199);
                                                                let mut v199 = v199.into_context_iter();
                                                                while let Some(v200) = v199.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v226,
                                                                        imm: v227,
                                                                    } = &v200.1 {
                                                                        if let &Opcode::Iconst = v226 {
                                                                            let v16 = C::u64_from_imm64(ctx, v15);
                                                                            let v228 = C::u64_from_imm64(ctx, v227);
                                                                            if v16 == v228 {
                                                                                let mut v127 = C::inst_data_etor_returns::default();
                                                                                C::inst_data_etor(ctx, v124.0, &mut v127);
                                                                                let mut v127 = v127.into_context_iter();
                                                                                while let Some(v128) = v127.next(ctx) {
                                                                                    if let &InstructionData::Unary {
                                                                                        opcode: ref v196,
                                                                                        arg: v197,
                                                                                    } = &v128.1 {
                                                                                        match v196 {
                                                                                            &Opcode::Uextend => {
                                                                                                if v2.0 == v128.0 {
                                                                                                    let v1147 = C::ty_bits_u64(ctx, v2.0);
                                                                                                    let v198 = C::value_type(ctx, v197);
                                                                                                    let v209 = C::ty_bits_u64(ctx, v198);
                                                                                                    let v1148 = C::u64_sub(ctx, v1147, v209);
                                                                                                    let v1149 = C::u64_eq(ctx, v228, v1148);
                                                                                                    if v1149 == true {
                                                                                                        let v1150 = constructor_sextend(ctx, v2.0, v197);
                                                                                                        // Rule at src/opts/shifts.isle line 49.
                                                                                                        returns.extend(Some(v1150));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                    let v1151 = C::u64_lt(ctx, v228, v1148);
                                                                                                    if v1151 == true {
                                                                                                        // Rule at src/opts/shifts.isle line 60.
                                                                                                        returns.extend(Some(v124.0));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                            &Opcode::Sextend => {
                                                                                                let v1147 = C::ty_bits_u64(ctx, v2.0);
                                                                                                let v198 = C::value_type(ctx, v197);
                                                                                                let v209 = C::ty_bits_u64(ctx, v198);
                                                                                                let v1148 = C::u64_sub(ctx, v1147, v209);
                                                                                                let v1152 = C::u64_le(ctx, v228, v1148);
                                                                                                if v1152 == true {
                                                                                                    if v2.0 == v128.0 {
                                                                                                        // Rule at src/opts/shifts.isle line 70.
                                                                                                        returns.extend(Some(v124.0));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                            _ => {}
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            if v15 == v227 {
                                                                                let v1153 = C::u64_is_zero(ctx, v228);
                                                                                if v1153 == false {
                                                                                    let v1154 = C::ty_bits(ctx, v2.0);
                                                                                    let v1155 = C::u8_as_u64(ctx, v1154);
                                                                                    let v1156 = C::u64_sub(ctx, v1155, v228);
                                                                                    let v1157 = constructor_shift_amt_to_type(ctx, v1156);
                                                                                    if let Some(v1158) = v1157 {
                                                                                        let v1159 = constructor_ireduce(ctx, v1158, v124.0);
                                                                                        let v1160 = constructor_sextend(ctx, v2.0, v1159);
                                                                                        // Rule at src/opts/shifts.isle line 83.
                                                                                        returns.extend(Some(v1160));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &Opcode::Sshr => {
                                                            if v2.0 == v19.0 {
                                                                let v124 = C::unpack_value_array_2(ctx, v123);
                                                                let mut v127 = C::inst_data_etor_returns::default();
                                                                C::inst_data_etor(ctx, v124.0, &mut v127);
                                                                let mut v127 = v127.into_context_iter();
                                                                while let Some(v128) = v127.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v617,
                                                                        imm: v618,
                                                                    } = &v128.1 {
                                                                        if let &Opcode::Iconst = v617 {
                                                                            let v684 = constructor_sshr(ctx, v2.0, v124.0, v7.1);
                                                                            let v685 = constructor_sshr(ctx, v2.0, v684, v124.1);
                                                                            // Rule at src/opts/cprop.isle line 215.
                                                                            returns.extend(Some(v685));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                let mut v199 = C::inst_data_etor_returns::default();
                                                                C::inst_data_etor(ctx, v124.1, &mut v199);
                                                                let mut v199 = v199.into_context_iter();
                                                                while let Some(v200) = v199.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v226,
                                                                        imm: v227,
                                                                    } = &v200.1 {
                                                                        if let &Opcode::Iconst = v226 {
                                                                            let v228 = C::u64_from_imm64(ctx, v227);
                                                                            let v235 = constructor_ty_shift_mask(ctx, v2.0);
                                                                            let v1183 = C::u64_and(ctx, v228, v235);
                                                                            let v16 = C::u64_from_imm64(ctx, v15);
                                                                            let v1184 = C::u64_and(ctx, v16, v235);
                                                                            let v1185 = C::u64_add(ctx, v1183, v1184);
                                                                            let v1186 = C::lane_type(ctx, v2.0);
                                                                            let v1187 = C::ty_bits_u64(ctx, v1186);
                                                                            let v1188 = C::u64_lt(ctx, v1185, v1187);
                                                                            if v1188 == true {
                                                                                let v1189 = constructor_iconst_u(ctx, v200.0, v1185);
                                                                                let v1192 = constructor_sshr(ctx, v2.0, v124.0, v1189);
                                                                                // Rule at src/opts/shifts.isle line 169.
                                                                                returns.extend(Some(v1192));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                &InstructionData::UnaryImm {
                                                    opcode: ref v22,
                                                    imm: v23,
                                                } => {
                                                    if let &Opcode::Iconst = v22 {
                                                        let v526 = C::fits_in_64(ctx, v2.0);
                                                        if let Some(v527) = v526 {
                                                            if v19.0 == v527 {
                                                                let v575 = C::imm64_sshr(ctx, v527, v23, v15);
                                                                let v576 = constructor_iconst(ctx, v527, v575);
                                                                let v577 = C::subsume(ctx, v576);
                                                                // Rule at src/opts/cprop.isle line 67.
                                                                returns.extend(Some(v577));
                                                                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 v235 = constructor_ty_shift_mask(ctx, v2.0);
                                        let v1184 = C::u64_and(ctx, v16, v235);
                                        let v1211 = C::u64_eq(ctx, v16, v1184);
                                        if v1211 == false {
                                            let v1212 = constructor_iconst_u(ctx, v11.0, v1184);
                                            let v1215 = constructor_sshr(ctx, v2.0, v7.0, v1212);
                                            // Rule at src/opts/shifts.isle line 298.
                                            returns.extend(Some(v1215));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                        let mut v18 = C::inst_data_etor_returns::default();
                        C::inst_data_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 v1186 = C::lane_type(ctx, v2.0);
                                        let v1355 = constructor_sshr(ctx, v1186, v30, v7.1);
                                        let v1356 = constructor_splat(ctx, v2.0, v1355);
                                        // Rule at src/opts/vector.isle line 80.
                                        returns.extend(Some(v1356));
                                        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_etor_returns::default();
                                C::inst_data_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 v727,
                                            imm: v728,
                                        } = &v11.1 {
                                            if let &Opcode::F32const = v727 {
                                                let mut v18 = C::inst_data_etor_returns::default();
                                                C::inst_data_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 v725,
                                                            imm: v726,
                                                        } = &v19.1 {
                                                            if let &Opcode::F32const = v725 {
                                                                let v729 = C::f32_add(ctx, v726, v728);
                                                                if let Some(v730) = v729 {
                                                                    let v731 = constructor_f32const(ctx, F32, v730);
                                                                    let v732 = C::subsume(ctx, v731);
                                                                    // Rule at src/opts/cprop.isle line 289.
                                                                    returns.extend(Some(v732));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            F64 => {
                                let v7 = C::unpack_value_array_2(ctx, v6);
                                let mut v10 = C::inst_data_etor_returns::default();
                                C::inst_data_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 v735,
                                            imm: v736,
                                        } = &v11.1 {
                                            if let &Opcode::F64const = v735 {
                                                let mut v18 = C::inst_data_etor_returns::default();
                                                C::inst_data_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 v733,
                                                            imm: v734,
                                                        } = &v19.1 {
                                                            if let &Opcode::F64const = v733 {
                                                                let v737 = C::f64_add(ctx, v734, v736);
                                                                if let Some(v738) = v737 {
                                                                    let v739 = constructor_f64const(ctx, F64, v738);
                                                                    let v740 = C::subsume(ctx, v739);
                                                                    // Rule at src/opts/cprop.isle line 292.
                                                                    returns.extend(Some(v740));
                                                                    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_etor_returns::default();
                                C::inst_data_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 v727,
                                            imm: v728,
                                        } = &v11.1 {
                                            if let &Opcode::F32const = v727 {
                                                let mut v18 = C::inst_data_etor_returns::default();
                                                C::inst_data_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 v725,
                                                            imm: v726,
                                                        } = &v19.1 {
                                                            if let &Opcode::F32const = v725 {
                                                                let v741 = C::f32_sub(ctx, v726, v728);
                                                                if let Some(v742) = v741 {
                                                                    let v743 = constructor_f32const(ctx, F32, v742);
                                                                    let v744 = C::subsume(ctx, v743);
                                                                    // Rule at src/opts/cprop.isle line 296.
                                                                    returns.extend(Some(v744));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            F64 => {
                                let v7 = C::unpack_value_array_2(ctx, v6);
                                let mut v10 = C::inst_data_etor_returns::default();
                                C::inst_data_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 v735,
                                            imm: v736,
                                        } = &v11.1 {
                                            if let &Opcode::F64const = v735 {
                                                let mut v18 = C::inst_data_etor_returns::default();
                                                C::inst_data_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 v733,
                                                            imm: v734,
                                                        } = &v19.1 {
                                                            if let &Opcode::F64const = v733 {
                                                                let v745 = C::f64_sub(ctx, v734, v736);
                                                                if let Some(v746) = v745 {
                                                                    let v747 = constructor_f64const(ctx, F64, v746);
                                                                    let v748 = C::subsume(ctx, v747);
                                                                    // Rule at src/opts/cprop.isle line 299.
                                                                    returns.extend(Some(v748));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            _ => {}
                        }
                    }
                    &Opcode::Fmul => {
                        let v7 = C::unpack_value_array_2(ctx, v6);
                        let mut v10 = C::inst_data_etor_returns::default();
                        C::inst_data_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_etor_returns::default();
                                            C::inst_data_etor(ctx, v7.0, &mut v18);
                                            let mut v18 = v18.into_context_iter();
                                            while let Some(v19) = v18.next(ctx) {
                                                if let &InstructionData::Unary {
                                                    opcode: ref v29,
                                                    arg: v30,
                                                } = &v19.1 {
                                                    if let &Opcode::Fneg = v29 {
                                                        if v2.0 == v19.0 {
                                                            let v103 = constructor_fmul(ctx, v2.0, v30, v27);
                                                            // Rule at src/opts/arithmetic.isle line 113.
                                                            returns.extend(Some(v103));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryIeee32 {
                                    opcode: ref v727,
                                    imm: v728,
                                } => {
                                    if let &Opcode::F32const = v727 {
                                        if v2.0 == F32 {
                                            if v11.0 == F32 {
                                                let mut v18 = C::inst_data_etor_returns::default();
                                                C::inst_data_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 v725,
                                                            imm: v726,
                                                        } = &v19.1 {
                                                            if let &Opcode::F32const = v725 {
                                                                let v749 = C::f32_mul(ctx, v726, v728);
                                                                if let Some(v750) = v749 {
                                                                    let v751 = constructor_f32const(ctx, F32, v750);
                                                                    let v752 = C::subsume(ctx, v751);
                                                                    // Rule at src/opts/cprop.isle line 303.
                                                                    returns.extend(Some(v752));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryIeee64 {
                                    opcode: ref v735,
                                    imm: v736,
                                } => {
                                    if let &Opcode::F64const = v735 {
                                        if v2.0 == F64 {
                                            if v11.0 == F64 {
                                                let mut v18 = C::inst_data_etor_returns::default();
                                                C::inst_data_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 v733,
                                                            imm: v734,
                                                        } = &v19.1 {
                                                            if let &Opcode::F64const = v733 {
                                                                let v753 = C::f64_mul(ctx, v734, v736);
                                                                if let Some(v754) = v753 {
                                                                    let v755 = constructor_f64const(ctx, F64, v754);
                                                                    let v756 = C::subsume(ctx, v755);
                                                                    // Rule at src/opts/cprop.isle line 306.
                                                                    returns.extend(Some(v756));
                                                                    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_etor_returns::default();
                                C::inst_data_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 v727,
                                            imm: v728,
                                        } = &v11.1 {
                                            if let &Opcode::F32const = v727 {
                                                let mut v18 = C::inst_data_etor_returns::default();
                                                C::inst_data_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 v725,
                                                            imm: v726,
                                                        } = &v19.1 {
                                                            if let &Opcode::F32const = v725 {
                                                                let v757 = C::f32_div(ctx, v726, v728);
                                                                if let Some(v758) = v757 {
                                                                    let v759 = constructor_f32const(ctx, F32, v758);
                                                                    let v760 = C::subsume(ctx, v759);
                                                                    // Rule at src/opts/cprop.isle line 310.
                                                                    returns.extend(Some(v760));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            F64 => {
                                let v7 = C::unpack_value_array_2(ctx, v6);
                                let mut v10 = C::inst_data_etor_returns::default();
                                C::inst_data_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 v735,
                                            imm: v736,
                                        } = &v11.1 {
                                            if let &Opcode::F64const = v735 {
                                                let mut v18 = C::inst_data_etor_returns::default();
                                                C::inst_data_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 v733,
                                                            imm: v734,
                                                        } = &v19.1 {
                                                            if let &Opcode::F64const = v733 {
                                                                let v761 = C::f64_div(ctx, v734, v736);
                                                                if let Some(v762) = v761 {
                                                                    let v763 = constructor_f64const(ctx, F64, v762);
                                                                    let v764 = C::subsume(ctx, v763);
                                                                    // Rule at src/opts/cprop.isle line 313.
                                                                    returns.extend(Some(v764));
                                                                    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_etor_returns::default();
                                C::inst_data_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 v807,
                                            imm: v808,
                                        } = &v11.1 {
                                            if let &Opcode::F16const = v807 {
                                                let mut v18 = C::inst_data_etor_returns::default();
                                                C::inst_data_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 v805,
                                                            imm: v806,
                                                        } = &v19.1 {
                                                            if let &Opcode::F16const = v805 {
                                                                let v885 = C::f16_copysign(ctx, v806, v808);
                                                                let v886 = constructor_f16const(ctx, F16, v885);
                                                                let v887 = C::subsume(ctx, v886);
                                                                // Rule at src/opts/cprop.isle line 396.
                                                                returns.extend(Some(v887));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            F32 => {
                                let v7 = C::unpack_value_array_2(ctx, v6);
                                let mut v10 = C::inst_data_etor_returns::default();
                                C::inst_data_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 v727,
                                            imm: v728,
                                        } = &v11.1 {
                                            if let &Opcode::F32const = v727 {
                                                let mut v18 = C::inst_data_etor_returns::default();
                                                C::inst_data_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 v725,
                                                            imm: v726,
                                                        } = &v19.1 {
                                                            if let &Opcode::F32const = v725 {
                                                                let v888 = C::f32_copysign(ctx, v726, v728);
                                                                let v889 = constructor_f32const(ctx, F32, v888);
                                                                let v890 = C::subsume(ctx, v889);
                                                                // Rule at src/opts/cprop.isle line 398.
                                                                returns.extend(Some(v890));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            F64 => {
                                let v7 = C::unpack_value_array_2(ctx, v6);
                                let mut v10 = C::inst_data_etor_returns::default();
                                C::inst_data_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 v735,
                                            imm: v736,
                                        } = &v11.1 {
                                            if let &Opcode::F64const = v735 {
                                                let mut v18 = C::inst_data_etor_returns::default();
                                                C::inst_data_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 v733,
                                                            imm: v734,
                                                        } = &v19.1 {
                                                            if let &Opcode::F64const = v733 {
                                                                let v891 = C::f64_copysign(ctx, v734, v736);
                                                                let v892 = constructor_f64const(ctx, F64, v891);
                                                                let v893 = C::subsume(ctx, v892);
                                                                // Rule at src/opts/cprop.isle line 400.
                                                                returns.extend(Some(v893));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            F128 => {
                                let v7 = C::unpack_value_array_2(ctx, v6);
                                let mut v10 = C::inst_data_etor_returns::default();
                                C::inst_data_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 v825,
                                            constant_handle: v826,
                                        } = &v11.1 {
                                            if let &Opcode::F128const = v825 {
                                                let v827 = C::ieee128_constant_extractor(ctx, v826);
                                                if let Some(v828) = v827 {
                                                    let mut v18 = C::inst_data_etor_returns::default();
                                                    C::inst_data_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 v821,
                                                                constant_handle: v822,
                                                            } = &v19.1 {
                                                                if let &Opcode::F128const = v821 {
                                                                    let v823 = C::ieee128_constant_extractor(ctx, v822);
                                                                    if let Some(v824) = v823 {
                                                                        let v894 = C::f128_copysign(ctx, v824, v828);
                                                                        let v895 = C::ieee128_constant(ctx, v894);
                                                                        let v896 = constructor_f128const(ctx, F128, v895);
                                                                        let v897 = C::subsume(ctx, v896);
                                                                        // Rule at src/opts/cprop.isle line 402.
                                                                        returns.extend(Some(v897));
                                                                        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_etor_returns::default();
                                C::inst_data_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 v807,
                                            imm: v808,
                                        } = &v11.1 {
                                            if let &Opcode::F16const = v807 {
                                                let mut v18 = C::inst_data_etor_returns::default();
                                                C::inst_data_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 v805,
                                                            imm: v806,
                                                        } = &v19.1 {
                                                            if let &Opcode::F16const = v805 {
                                                                let v809 = C::f16_min(ctx, v806, v808);
                                                                if let Some(v810) = v809 {
                                                                    let v811 = constructor_f16const(ctx, F32, v810);
                                                                    let v812 = C::subsume(ctx, v811);
                                                                    // Rule at src/opts/cprop.isle line 352.
                                                                    returns.extend(Some(v812));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            F32 => {
                                let v7 = C::unpack_value_array_2(ctx, v6);
                                let mut v10 = C::inst_data_etor_returns::default();
                                C::inst_data_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 v727,
                                            imm: v728,
                                        } = &v11.1 {
                                            if let &Opcode::F32const = v727 {
                                                let mut v18 = C::inst_data_etor_returns::default();
                                                C::inst_data_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 v725,
                                                            imm: v726,
                                                        } = &v19.1 {
                                                            if let &Opcode::F32const = v725 {
                                                                let v813 = C::f32_min(ctx, v726, v728);
                                                                if let Some(v814) = v813 {
                                                                    let v815 = constructor_f32const(ctx, F32, v814);
                                                                    let v816 = C::subsume(ctx, v815);
                                                                    // Rule at src/opts/cprop.isle line 355.
                                                                    returns.extend(Some(v816));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            F64 => {
                                let v7 = C::unpack_value_array_2(ctx, v6);
                                let mut v10 = C::inst_data_etor_returns::default();
                                C::inst_data_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 v735,
                                            imm: v736,
                                        } = &v11.1 {
                                            if let &Opcode::F64const = v735 {
                                                let mut v18 = C::inst_data_etor_returns::default();
                                                C::inst_data_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 v733,
                                                            imm: v734,
                                                        } = &v19.1 {
                                                            if let &Opcode::F64const = v733 {
                                                                let v817 = C::f64_min(ctx, v734, v736);
                                                                if let Some(v818) = v817 {
                                                                    let v819 = constructor_f64const(ctx, F64, v818);
                                                                    let v820 = C::subsume(ctx, v819);
                                                                    // Rule at src/opts/cprop.isle line 358.
                                                                    returns.extend(Some(v820));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            F128 => {
                                let v7 = C::unpack_value_array_2(ctx, v6);
                                let mut v10 = C::inst_data_etor_returns::default();
                                C::inst_data_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 v825,
                                            constant_handle: v826,
                                        } = &v11.1 {
                                            if let &Opcode::F128const = v825 {
                                                let v827 = C::ieee128_constant_extractor(ctx, v826);
                                                if let Some(v828) = v827 {
                                                    let mut v18 = C::inst_data_etor_returns::default();
                                                    C::inst_data_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 v821,
                                                                constant_handle: v822,
                                                            } = &v19.1 {
                                                                if let &Opcode::F128const = v821 {
                                                                    let v823 = C::ieee128_constant_extractor(ctx, v822);
                                                                    if let Some(v824) = v823 {
                                                                        let v829 = C::f128_min(ctx, v824, v828);
                                                                        if let Some(v830) = v829 {
                                                                            let v832 = C::ieee128_constant(ctx, v830);
                                                                            let v833 = constructor_f128const(ctx, F128, v832);
                                                                            let v834 = C::subsume(ctx, v833);
                                                                            // Rule at src/opts/cprop.isle line 361.
                                                                            returns.extend(Some(v834));
                                                                            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_etor_returns::default();
                                C::inst_data_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 v807,
                                            imm: v808,
                                        } = &v11.1 {
                                            if let &Opcode::F16const = v807 {
                                                let mut v18 = C::inst_data_etor_returns::default();
                                                C::inst_data_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 v805,
                                                            imm: v806,
                                                        } = &v19.1 {
                                                            if let &Opcode::F16const = v805 {
                                                                let v835 = C::f16_max(ctx, v806, v808);
                                                                if let Some(v836) = v835 {
                                                                    let v838 = constructor_f16const(ctx, F16, v836);
                                                                    let v839 = C::subsume(ctx, v838);
                                                                    // Rule at src/opts/cprop.isle line 365.
                                                                    returns.extend(Some(v839));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            F32 => {
                                let v7 = C::unpack_value_array_2(ctx, v6);
                                let mut v10 = C::inst_data_etor_returns::default();
                                C::inst_data_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 v727,
                                            imm: v728,
                                        } = &v11.1 {
                                            if let &Opcode::F32const = v727 {
                                                let mut v18 = C::inst_data_etor_returns::default();
                                                C::inst_data_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 v725,
                                                            imm: v726,
                                                        } = &v19.1 {
                                                            if let &Opcode::F32const = v725 {
                                                                let v840 = C::f32_max(ctx, v726, v728);
                                                                if let Some(v841) = v840 {
                                                                    let v842 = constructor_f32const(ctx, F32, v841);
                                                                    let v843 = C::subsume(ctx, v842);
                                                                    // Rule at src/opts/cprop.isle line 368.
                                                                    returns.extend(Some(v843));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            F64 => {
                                let v7 = C::unpack_value_array_2(ctx, v6);
                                let mut v10 = C::inst_data_etor_returns::default();
                                C::inst_data_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 v735,
                                            imm: v736,
                                        } = &v11.1 {
                                            if let &Opcode::F64const = v735 {
                                                let mut v18 = C::inst_data_etor_returns::default();
                                                C::inst_data_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 v733,
                                                            imm: v734,
                                                        } = &v19.1 {
                                                            if let &Opcode::F64const = v733 {
                                                                let v844 = C::f64_max(ctx, v734, v736);
                                                                if let Some(v845) = v844 {
                                                                    let v846 = constructor_f64const(ctx, F64, v845);
                                                                    let v847 = C::subsume(ctx, v846);
                                                                    // Rule at src/opts/cprop.isle line 371.
                                                                    returns.extend(Some(v847));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            F128 => {
                                let v7 = C::unpack_value_array_2(ctx, v6);
                                let mut v10 = C::inst_data_etor_returns::default();
                                C::inst_data_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 v825,
                                            constant_handle: v826,
                                        } = &v11.1 {
                                            if let &Opcode::F128const = v825 {
                                                let v827 = C::ieee128_constant_extractor(ctx, v826);
                                                if let Some(v828) = v827 {
                                                    let mut v18 = C::inst_data_etor_returns::default();
                                                    C::inst_data_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 v821,
                                                                constant_handle: v822,
                                                            } = &v19.1 {
                                                                if let &Opcode::F128const = v821 {
                                                                    let v823 = C::ieee128_constant_extractor(ctx, v822);
                                                                    if let Some(v824) = v823 {
                                                                        let v848 = C::f128_max(ctx, v824, v828);
                                                                        if let Some(v849) = v848 {
                                                                            let v850 = C::ieee128_constant(ctx, v849);
                                                                            let v851 = constructor_f128const(ctx, F128, v850);
                                                                            let v852 = C::subsume(ctx, v851);
                                                                            // Rule at src/opts/cprop.isle line 374.
                                                                            returns.extend(Some(v852));
                                                                            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_etor_returns::default();
                            C::inst_data_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 v104,
                                        args: ref v105,
                                    } => {
                                        if let &Opcode::Sshr = v104 {
                                            let v106 = C::unpack_value_array_2(ctx, v105);
                                            if v7.0 == v106.0 {
                                                let mut v109 = C::inst_data_etor_returns::default();
                                                C::inst_data_etor(ctx, v106.1, &mut v109);
                                                let mut v109 = v109.into_context_iter();
                                                while let Some(v110) = v109.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v686,
                                                        imm: v687,
                                                    } = &v110.1 {
                                                        if let &Opcode::Iconst = v686 {
                                                            let v956 = C::u64_from_imm64(ctx, v687);
                                                            if v956 == 0x3f_u64 {
                                                                let v957 = constructor_sextend(ctx, I128, v7.0);
                                                                // Rule at src/opts/extends.isle line 94.
                                                                returns.extend(Some(v957));
                                                                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 v955 = constructor_uextend(ctx, I128, v7.0);
                                                // Rule at src/opts/extends.isle line 93.
                                                returns.extend(Some(v955));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                        }
                    }
                    _ => {}
                }
            }
            &InstructionData::IntCompare {
                opcode: ref v253,
                args: ref v254,
                cond: ref v255,
            } => {
                if let &Opcode::Icmp = v253 {
                    match v255 {
                        &IntCC::Equal => {
                            let v256 = C::unpack_value_array_2(ctx, v254);
                            let mut v593 = C::inst_data_etor_returns::default();
                            C::inst_data_etor(ctx, v256.0, &mut v593);
                            let mut v593 = v593.into_context_iter();
                            while let Some(v594) = v593.next(ctx) {
                                match &v594.1 {
                                    &InstructionData::Binary {
                                        opcode: ref v1274,
                                        args: ref v1275,
                                    } => {
                                        if let &Opcode::Isub = v1274 {
                                            if v594.0 == I8 {
                                                let mut v915 = C::inst_data_tupled_etor_returns::default();
                                                C::inst_data_tupled_etor(ctx, v256.1, &mut v915);
                                                let mut v915 = v915.into_context_iter();
                                                while let Some(v916) = v915.next(ctx) {
                                                    let v917 = C::iconst_sextend_etor(ctx, v916);
                                                    if let Some(v918) = v917 {
                                                        match v918.1 {
                                                            -1_i64 => {
                                                                let v1276 = C::unpack_value_array_2(ctx, v1275);
                                                                let mut v1279 = C::inst_data_etor_returns::default();
                                                                C::inst_data_etor(ctx, v1276.0, &mut v1279);
                                                                let mut v1279 = v1279.into_context_iter();
                                                                while let Some(v1280) = v1279.next(ctx) {
                                                                    if let &InstructionData::IntCompare {
                                                                        opcode: ref v1283,
                                                                        args: ref v1284,
                                                                        cond: ref v1285,
                                                                    } = &v1280.1 {
                                                                        if let &Opcode::Icmp = v1283 {
                                                                            match v1285 {
                                                                                &IntCC::SignedGreaterThan => {
                                                                                    let mut v1289 = C::inst_data_etor_returns::default();
                                                                                    C::inst_data_etor(ctx, v1276.1, &mut v1289);
                                                                                    let mut v1289 = v1289.into_context_iter();
                                                                                    while let Some(v1290) = v1289.next(ctx) {
                                                                                        if let &InstructionData::IntCompare {
                                                                                            opcode: ref v1293,
                                                                                            args: ref v1294,
                                                                                            cond: ref v1295,
                                                                                        } = &v1290.1 {
                                                                                            if let &Opcode::Icmp = v1293 {
                                                                                                if let &IntCC::SignedLessThan = v1295 {
                                                                                                    if v1280.0 == v1290.0 {
                                                                                                        let v1286 = C::unpack_value_array_2(ctx, v1284);
                                                                                                        let v1296 = C::unpack_value_array_2(ctx, v1294);
                                                                                                        if v1286.0 == v1296.0 {
                                                                                                            if v1286.1 == v1296.1 {
                                                                                                                let v1301 = constructor_slt(ctx, v1280.0, v1286.0, v1286.1);
                                                                                                                // Rule at src/opts/spaceship.isle line 178.
                                                                                                                returns.extend(Some(v1301));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                                &IntCC::UnsignedGreaterThan => {
                                                                                    let mut v1289 = C::inst_data_etor_returns::default();
                                                                                    C::inst_data_etor(ctx, v1276.1, &mut v1289);
                                                                                    let mut v1289 = v1289.into_context_iter();
                                                                                    while let Some(v1290) = v1289.next(ctx) {
                                                                                        if let &InstructionData::IntCompare {
                                                                                            opcode: ref v1293,
                                                                                            args: ref v1294,
                                                                                            cond: ref v1295,
                                                                                        } = &v1290.1 {
                                                                                            if let &Opcode::Icmp = v1293 {
                                                                                                if let &IntCC::UnsignedLessThan = v1295 {
                                                                                                    if v1280.0 == v1290.0 {
                                                                                                        let v1286 = C::unpack_value_array_2(ctx, v1284);
                                                                                                        let v1296 = C::unpack_value_array_2(ctx, v1294);
                                                                                                        if v1286.0 == v1296.0 {
                                                                                                            if v1286.1 == v1296.1 {
                                                                                                                let v1302 = constructor_ult(ctx, v1280.0, v1286.0, v1286.1);
                                                                                                                // Rule at src/opts/spaceship.isle line 180.
                                                                                                                returns.extend(Some(v1302));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                                _ => {}
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            0_i64 => {
                                                                let v1276 = C::unpack_value_array_2(ctx, v1275);
                                                                let mut v1279 = C::inst_data_etor_returns::default();
                                                                C::inst_data_etor(ctx, v1276.0, &mut v1279);
                                                                let mut v1279 = v1279.into_context_iter();
                                                                while let Some(v1280) = v1279.next(ctx) {
                                                                    if let &InstructionData::IntCompare {
                                                                        opcode: ref v1283,
                                                                        args: ref v1284,
                                                                        cond: ref v1285,
                                                                    } = &v1280.1 {
                                                                        if let &Opcode::Icmp = v1283 {
                                                                            match v1285 {
                                                                                &IntCC::SignedGreaterThan => {
                                                                                    let mut v1289 = C::inst_data_etor_returns::default();
                                                                                    C::inst_data_etor(ctx, v1276.1, &mut v1289);
                                                                                    let mut v1289 = v1289.into_context_iter();
                                                                                    while let Some(v1290) = v1289.next(ctx) {
                                                                                        if let &InstructionData::IntCompare {
                                                                                            opcode: ref v1293,
                                                                                            args: ref v1294,
                                                                                            cond: ref v1295,
                                                                                        } = &v1290.1 {
                                                                                            if let &Opcode::Icmp = v1293 {
                                                                                                if let &IntCC::SignedLessThan = v1295 {
                                                                                                    if v1280.0 == v1290.0 {
                                                                                                        let v1286 = C::unpack_value_array_2(ctx, v1284);
                                                                                                        let v1296 = C::unpack_value_array_2(ctx, v1294);
                                                                                                        if v1286.0 == v1296.0 {
                                                                                                            if v1286.1 == v1296.1 {
                                                                                                                let v1299 = constructor_eq(ctx, v1280.0, v1286.0, v1286.1);
                                                                                                                // Rule at src/opts/spaceship.isle line 145.
                                                                                                                returns.extend(Some(v1299));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                                &IntCC::UnsignedGreaterThan => {
                                                                                    let mut v1289 = C::inst_data_etor_returns::default();
                                                                                    C::inst_data_etor(ctx, v1276.1, &mut v1289);
                                                                                    let mut v1289 = v1289.into_context_iter();
                                                                                    while let Some(v1290) = v1289.next(ctx) {
                                                                                        if let &InstructionData::IntCompare {
                                                                                            opcode: ref v1293,
                                                                                            args: ref v1294,
                                                                                            cond: ref v1295,
                                                                                        } = &v1290.1 {
                                                                                            if let &Opcode::Icmp = v1293 {
                                                                                                if let &IntCC::UnsignedLessThan = v1295 {
                                                                                                    if v1280.0 == v1290.0 {
                                                                                                        let v1286 = C::unpack_value_array_2(ctx, v1284);
                                                                                                        let v1296 = C::unpack_value_array_2(ctx, v1294);
                                                                                                        if v1286.0 == v1296.0 {
                                                                                                            if v1286.1 == v1296.1 {
                                                                                                                let v1299 = constructor_eq(ctx, v1280.0, v1286.0, v1286.1);
                                                                                                                // Rule at src/opts/spaceship.isle line 147.
                                                                                                                returns.extend(Some(v1299));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                                _ => {}
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            1_i64 => {
                                                                let v1276 = C::unpack_value_array_2(ctx, v1275);
                                                                let mut v1279 = C::inst_data_etor_returns::default();
                                                                C::inst_data_etor(ctx, v1276.0, &mut v1279);
                                                                let mut v1279 = v1279.into_context_iter();
                                                                while let Some(v1280) = v1279.next(ctx) {
                                                                    if let &InstructionData::IntCompare {
                                                                        opcode: ref v1283,
                                                                        args: ref v1284,
                                                                        cond: ref v1285,
                                                                    } = &v1280.1 {
                                                                        if let &Opcode::Icmp = v1283 {
                                                                            match v1285 {
                                                                                &IntCC::SignedGreaterThan => {
                                                                                    let mut v1289 = C::inst_data_etor_returns::default();
                                                                                    C::inst_data_etor(ctx, v1276.1, &mut v1289);
                                                                                    let mut v1289 = v1289.into_context_iter();
                                                                                    while let Some(v1290) = v1289.next(ctx) {
                                                                                        if let &InstructionData::IntCompare {
                                                                                            opcode: ref v1293,
                                                                                            args: ref v1294,
                                                                                            cond: ref v1295,
                                                                                        } = &v1290.1 {
                                                                                            if let &Opcode::Icmp = v1293 {
                                                                                                if let &IntCC::SignedLessThan = v1295 {
                                                                                                    if v1280.0 == v1290.0 {
                                                                                                        let v1286 = C::unpack_value_array_2(ctx, v1284);
                                                                                                        let v1296 = C::unpack_value_array_2(ctx, v1294);
                                                                                                        if v1286.0 == v1296.0 {
                                                                                                            if v1286.1 == v1296.1 {
                                                                                                                let v1305 = constructor_sgt(ctx, v1280.0, v1286.0, v1286.1);
                                                                                                                // Rule at src/opts/spaceship.isle line 186.
                                                                                                                returns.extend(Some(v1305));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                                &IntCC::UnsignedGreaterThan => {
                                                                                    let mut v1289 = C::inst_data_etor_returns::default();
                                                                                    C::inst_data_etor(ctx, v1276.1, &mut v1289);
                                                                                    let mut v1289 = v1289.into_context_iter();
                                                                                    while let Some(v1290) = v1289.next(ctx) {
                                                                                        if let &InstructionData::IntCompare {
                                                                                            opcode: ref v1293,
                                                                                            args: ref v1294,
                                                                                            cond: ref v1295,
                                                                                        } = &v1290.1 {
                                                                                            if let &Opcode::Icmp = v1293 {
                                                                                                if let &IntCC::UnsignedLessThan = v1295 {
                                                                                                    if v1280.0 == v1290.0 {
                                                                                                        let v1286 = C::unpack_value_array_2(ctx, v1284);
                                                                                                        let v1296 = C::unpack_value_array_2(ctx, v1294);
                                                                                                        if v1286.0 == v1296.0 {
                                                                                                            if v1286.1 == v1296.1 {
                                                                                                                let v1306 = constructor_ugt(ctx, v1280.0, v1286.0, v1286.1);
                                                                                                                // Rule at src/opts/spaceship.isle line 188.
                                                                                                                returns.extend(Some(v1306));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                                _ => {}
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    &InstructionData::Unary {
                                        opcode: ref v907,
                                        arg: v908,
                                    } => {
                                        if let &Opcode::Sextend = v907 {
                                            let mut v915 = C::inst_data_tupled_etor_returns::default();
                                            C::inst_data_tupled_etor(ctx, v256.1, &mut v915);
                                            let mut v915 = v915.into_context_iter();
                                            while let Some(v916) = v915.next(ctx) {
                                                let v917 = C::iconst_sextend_etor(ctx, v916);
                                                if let Some(v918) = v917 {
                                                    if v918.1 == 0_i64 {
                                                        let v909 = C::value_type(ctx, v908);
                                                        let v922 = constructor_iconst_s(ctx, v909, 0_i64);
                                                        let v923 = constructor_eq(ctx, v909, v908, v922);
                                                        // Rule at src/opts/extends.isle line 39.
                                                        returns.extend(Some(v923));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                            let mut v259 = C::inst_data_etor_returns::default();
                            C::inst_data_etor(ctx, v256.1, &mut v259);
                            let mut v259 = v259.into_context_iter();
                            while let Some(v260) = v259.next(ctx) {
                                if let &InstructionData::UnaryImm {
                                    opcode: ref v263,
                                    imm: v264,
                                } = &v260.1 {
                                    if let &Opcode::Iconst = v263 {
                                        let v265 = C::u64_from_imm64(ctx, v264);
                                        match v265 {
                                            0x0_u64 => {
                                                let mut v960 = C::uextend_maybe_etor_returns::default();
                                                C::uextend_maybe_etor(ctx, v256.0, &mut v960);
                                                let mut v960 = v960.into_context_iter();
                                                while let Some(v961) = v960.next(ctx) {
                                                    let mut v964 = C::inst_data_etor_returns::default();
                                                    C::inst_data_etor(ctx, v961.1, &mut v964);
                                                    let mut v964 = v964.into_context_iter();
                                                    while let Some(v965) = v964.next(ctx) {
                                                        if let &InstructionData::IntCompare {
                                                            opcode: ref v968,
                                                            args: ref v969,
                                                            cond: ref v970,
                                                        } = &v965.1 {
                                                            if let &Opcode::Icmp = v968 {
                                                                if v2.0 == v965.0 {
                                                                    let v975 = &C::intcc_complement(ctx, v970);
                                                                    let v971 = C::unpack_value_array_2(ctx, v969);
                                                                    let v976 = constructor_icmp(ctx, v2.0, v975, v971.0, v971.1);
                                                                    let v977 = C::subsume(ctx, v976);
                                                                    // Rule at src/opts/icmp.isle line 25.
                                                                    returns.extend(Some(v977));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            0x1_u64 => {
                                                let mut v960 = C::uextend_maybe_etor_returns::default();
                                                C::uextend_maybe_etor(ctx, v256.0, &mut v960);
                                                let mut v960 = v960.into_context_iter();
                                                while let Some(v961) = v960.next(ctx) {
                                                    let mut v964 = C::inst_data_etor_returns::default();
                                                    C::inst_data_etor(ctx, v961.1, &mut v964);
                                                    let mut v964 = v964.into_context_iter();
                                                    while let Some(v965) = v964.next(ctx) {
                                                        if let &InstructionData::IntCompare {
                                                            opcode: ref v968,
                                                            args: ref v969,
                                                            cond: ref v970,
                                                        } = &v965.1 {
                                                            if let &Opcode::Icmp = v968 {
                                                                let v974 = C::subsume(ctx, v961.1);
                                                                // Rule at src/opts/icmp.isle line 39.
                                                                returns.extend(Some(v974));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                }
                            }
                            if v256.0 == v256.1 {
                                let v52 = C::ty_int(ctx, v2.0);
                                if let Some(v53) = v52 {
                                    let v958 = constructor_iconst_u(ctx, v53, 0x1_u64);
                                    let v959 = C::subsume(ctx, v958);
                                    // Rule at src/opts/icmp.isle line 4.
                                    returns.extend(Some(v959));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                        }
                        &IntCC::NotEqual => {
                            let v256 = C::unpack_value_array_2(ctx, v254);
                            let mut v593 = C::inst_data_etor_returns::default();
                            C::inst_data_etor(ctx, v256.0, &mut v593);
                            let mut v593 = v593.into_context_iter();
                            while let Some(v594) = v593.next(ctx) {
                                match &v594.1 {
                                    &InstructionData::Binary {
                                        opcode: ref v1274,
                                        args: ref v1275,
                                    } => {
                                        if let &Opcode::Isub = v1274 {
                                            if v594.0 == I8 {
                                                let mut v915 = C::inst_data_tupled_etor_returns::default();
                                                C::inst_data_tupled_etor(ctx, v256.1, &mut v915);
                                                let mut v915 = v915.into_context_iter();
                                                while let Some(v916) = v915.next(ctx) {
                                                    let v917 = C::iconst_sextend_etor(ctx, v916);
                                                    if let Some(v918) = v917 {
                                                        match v918.1 {
                                                            -1_i64 => {
                                                                let v1276 = C::unpack_value_array_2(ctx, v1275);
                                                                let mut v1279 = C::inst_data_etor_returns::default();
                                                                C::inst_data_etor(ctx, v1276.0, &mut v1279);
                                                                let mut v1279 = v1279.into_context_iter();
                                                                while let Some(v1280) = v1279.next(ctx) {
                                                                    if let &InstructionData::IntCompare {
                                                                        opcode: ref v1283,
                                                                        args: ref v1284,
                                                                        cond: ref v1285,
                                                                    } = &v1280.1 {
                                                                        if let &Opcode::Icmp = v1283 {
                                                                            match v1285 {
                                                                                &IntCC::SignedGreaterThan => {
                                                                                    let mut v1289 = C::inst_data_etor_returns::default();
                                                                                    C::inst_data_etor(ctx, v1276.1, &mut v1289);
                                                                                    let mut v1289 = v1289.into_context_iter();
                                                                                    while let Some(v1290) = v1289.next(ctx) {
                                                                                        if let &InstructionData::IntCompare {
                                                                                            opcode: ref v1293,
                                                                                            args: ref v1294,
                                                                                            cond: ref v1295,
                                                                                        } = &v1290.1 {
                                                                                            if let &Opcode::Icmp = v1293 {
                                                                                                if let &IntCC::SignedLessThan = v1295 {
                                                                                                    if v1280.0 == v1290.0 {
                                                                                                        let v1286 = C::unpack_value_array_2(ctx, v1284);
                                                                                                        let v1296 = C::unpack_value_array_2(ctx, v1294);
                                                                                                        if v1286.0 == v1296.0 {
                                                                                                            if v1286.1 == v1296.1 {
                                                                                                                let v1307 = constructor_sge(ctx, v1280.0, v1286.0, v1286.1);
                                                                                                                // Rule at src/opts/spaceship.isle line 182.
                                                                                                                returns.extend(Some(v1307));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                                &IntCC::UnsignedGreaterThan => {
                                                                                    let mut v1289 = C::inst_data_etor_returns::default();
                                                                                    C::inst_data_etor(ctx, v1276.1, &mut v1289);
                                                                                    let mut v1289 = v1289.into_context_iter();
                                                                                    while let Some(v1290) = v1289.next(ctx) {
                                                                                        if let &InstructionData::IntCompare {
                                                                                            opcode: ref v1293,
                                                                                            args: ref v1294,
                                                                                            cond: ref v1295,
                                                                                        } = &v1290.1 {
                                                                                            if let &Opcode::Icmp = v1293 {
                                                                                                if let &IntCC::UnsignedLessThan = v1295 {
                                                                                                    if v1280.0 == v1290.0 {
                                                                                                        let v1286 = C::unpack_value_array_2(ctx, v1284);
                                                                                                        let v1296 = C::unpack_value_array_2(ctx, v1294);
                                                                                                        if v1286.0 == v1296.0 {
                                                                                                            if v1286.1 == v1296.1 {
                                                                                                                let v1308 = constructor_uge(ctx, v1280.0, v1286.0, v1286.1);
                                                                                                                // Rule at src/opts/spaceship.isle line 184.
                                                                                                                returns.extend(Some(v1308));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                                _ => {}
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            0_i64 => {
                                                                let v1276 = C::unpack_value_array_2(ctx, v1275);
                                                                let mut v1279 = C::inst_data_etor_returns::default();
                                                                C::inst_data_etor(ctx, v1276.0, &mut v1279);
                                                                let mut v1279 = v1279.into_context_iter();
                                                                while let Some(v1280) = v1279.next(ctx) {
                                                                    if let &InstructionData::IntCompare {
                                                                        opcode: ref v1283,
                                                                        args: ref v1284,
                                                                        cond: ref v1285,
                                                                    } = &v1280.1 {
                                                                        if let &Opcode::Icmp = v1283 {
                                                                            match v1285 {
                                                                                &IntCC::SignedGreaterThan => {
                                                                                    let mut v1289 = C::inst_data_etor_returns::default();
                                                                                    C::inst_data_etor(ctx, v1276.1, &mut v1289);
                                                                                    let mut v1289 = v1289.into_context_iter();
                                                                                    while let Some(v1290) = v1289.next(ctx) {
                                                                                        if let &InstructionData::IntCompare {
                                                                                            opcode: ref v1293,
                                                                                            args: ref v1294,
                                                                                            cond: ref v1295,
                                                                                        } = &v1290.1 {
                                                                                            if let &Opcode::Icmp = v1293 {
                                                                                                if let &IntCC::SignedLessThan = v1295 {
                                                                                                    if v1280.0 == v1290.0 {
                                                                                                        let v1286 = C::unpack_value_array_2(ctx, v1284);
                                                                                                        let v1296 = C::unpack_value_array_2(ctx, v1294);
                                                                                                        if v1286.0 == v1296.0 {
                                                                                                            if v1286.1 == v1296.1 {
                                                                                                                let v1300 = constructor_ne(ctx, v1280.0, v1286.0, v1286.1);
                                                                                                                // Rule at src/opts/spaceship.isle line 150.
                                                                                                                returns.extend(Some(v1300));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                                &IntCC::UnsignedGreaterThan => {
                                                                                    let mut v1289 = C::inst_data_etor_returns::default();
                                                                                    C::inst_data_etor(ctx, v1276.1, &mut v1289);
                                                                                    let mut v1289 = v1289.into_context_iter();
                                                                                    while let Some(v1290) = v1289.next(ctx) {
                                                                                        if let &InstructionData::IntCompare {
                                                                                            opcode: ref v1293,
                                                                                            args: ref v1294,
                                                                                            cond: ref v1295,
                                                                                        } = &v1290.1 {
                                                                                            if let &Opcode::Icmp = v1293 {
                                                                                                if let &IntCC::UnsignedLessThan = v1295 {
                                                                                                    if v1280.0 == v1290.0 {
                                                                                                        let v1286 = C::unpack_value_array_2(ctx, v1284);
                                                                                                        let v1296 = C::unpack_value_array_2(ctx, v1294);
                                                                                                        if v1286.0 == v1296.0 {
                                                                                                            if v1286.1 == v1296.1 {
                                                                                                                let v1300 = constructor_ne(ctx, v1280.0, v1286.0, v1286.1);
                                                                                                                // Rule at src/opts/spaceship.isle line 152.
                                                                                                                returns.extend(Some(v1300));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                                _ => {}
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            1_i64 => {
                                                                let v1276 = C::unpack_value_array_2(ctx, v1275);
                                                                let mut v1279 = C::inst_data_etor_returns::default();
                                                                C::inst_data_etor(ctx, v1276.0, &mut v1279);
                                                                let mut v1279 = v1279.into_context_iter();
                                                                while let Some(v1280) = v1279.next(ctx) {
                                                                    if let &InstructionData::IntCompare {
                                                                        opcode: ref v1283,
                                                                        args: ref v1284,
                                                                        cond: ref v1285,
                                                                    } = &v1280.1 {
                                                                        if let &Opcode::Icmp = v1283 {
                                                                            match v1285 {
                                                                                &IntCC::SignedGreaterThan => {
                                                                                    let mut v1289 = C::inst_data_etor_returns::default();
                                                                                    C::inst_data_etor(ctx, v1276.1, &mut v1289);
                                                                                    let mut v1289 = v1289.into_context_iter();
                                                                                    while let Some(v1290) = v1289.next(ctx) {
                                                                                        if let &InstructionData::IntCompare {
                                                                                            opcode: ref v1293,
                                                                                            args: ref v1294,
                                                                                            cond: ref v1295,
                                                                                        } = &v1290.1 {
                                                                                            if let &Opcode::Icmp = v1293 {
                                                                                                if let &IntCC::SignedLessThan = v1295 {
                                                                                                    if v1280.0 == v1290.0 {
                                                                                                        let v1286 = C::unpack_value_array_2(ctx, v1284);
                                                                                                        let v1296 = C::unpack_value_array_2(ctx, v1294);
                                                                                                        if v1286.0 == v1296.0 {
                                                                                                            if v1286.1 == v1296.1 {
                                                                                                                let v1303 = constructor_sle(ctx, v1280.0, v1286.0, v1286.1);
                                                                                                                // Rule at src/opts/spaceship.isle line 190.
                                                                                                                returns.extend(Some(v1303));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                                &IntCC::UnsignedGreaterThan => {
                                                                                    let mut v1289 = C::inst_data_etor_returns::default();
                                                                                    C::inst_data_etor(ctx, v1276.1, &mut v1289);
                                                                                    let mut v1289 = v1289.into_context_iter();
                                                                                    while let Some(v1290) = v1289.next(ctx) {
                                                                                        if let &InstructionData::IntCompare {
                                                                                            opcode: ref v1293,
                                                                                            args: ref v1294,
                                                                                            cond: ref v1295,
                                                                                        } = &v1290.1 {
                                                                                            if let &Opcode::Icmp = v1293 {
                                                                                                if let &IntCC::UnsignedLessThan = v1295 {
                                                                                                    if v1280.0 == v1290.0 {
                                                                                                        let v1286 = C::unpack_value_array_2(ctx, v1284);
                                                                                                        let v1296 = C::unpack_value_array_2(ctx, v1294);
                                                                                                        if v1286.0 == v1296.0 {
                                                                                                            if v1286.1 == v1296.1 {
                                                                                                                let v1304 = constructor_ule(ctx, v1280.0, v1286.0, v1286.1);
                                                                                                                // Rule at src/opts/spaceship.isle line 192.
                                                                                                                returns.extend(Some(v1304));
                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                                _ => {}
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    &InstructionData::Unary {
                                        opcode: ref v907,
                                        arg: v908,
                                    } => {
                                        if let &Opcode::Sextend = v907 {
                                            let mut v915 = C::inst_data_tupled_etor_returns::default();
                                            C::inst_data_tupled_etor(ctx, v256.1, &mut v915);
                                            let mut v915 = v915.into_context_iter();
                                            while let Some(v916) = v915.next(ctx) {
                                                let v917 = C::iconst_sextend_etor(ctx, v916);
                                                if let Some(v918) = v917 {
                                                    if v918.1 == 0_i64 {
                                                        let v909 = C::value_type(ctx, v908);
                                                        let v922 = constructor_iconst_s(ctx, v909, 0_i64);
                                                        let v924 = constructor_ne(ctx, v909, v908, v922);
                                                        // Rule at src/opts/extends.isle line 41.
                                                        returns.extend(Some(v924));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                            let mut v259 = C::inst_data_etor_returns::default();
                            C::inst_data_etor(ctx, v256.1, &mut v259);
                            let mut v259 = v259.into_context_iter();
                            while let Some(v260) = v259.next(ctx) {
                                if let &InstructionData::UnaryImm {
                                    opcode: ref v263,
                                    imm: v264,
                                } = &v260.1 {
                                    if let &Opcode::Iconst = v263 {
                                        let v265 = C::u64_from_imm64(ctx, v264);
                                        match v265 {
                                            0x0_u64 => {
                                                let mut v266 = ContextIterWrapper::<ConstructorVec<_>, _>::default();
                                                constructor_truthy(ctx, v256.0, &mut v266);
                                                let mut v266 = v266.into_context_iter();
                                                while let Some(v267) = v266.next(ctx) {
                                                    let v268 = C::value_type(ctx, v267);
                                                    let v269 = C::ty_int_ref_scalar_64_extract(ctx, v268);
                                                    if let Some(v270) = v269 {
                                                        let v271 = constructor_iconst_u(ctx, v270, 0x0_u64);
                                                        let v272 = constructor_ne(ctx, v2.0, v267, v271);
                                                        // Rule at src/opts/bitops.isle line 119.
                                                        returns.extend(Some(v272));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                let mut v960 = C::uextend_maybe_etor_returns::default();
                                                C::uextend_maybe_etor(ctx, v256.0, &mut v960);
                                                let mut v960 = v960.into_context_iter();
                                                while let Some(v961) = v960.next(ctx) {
                                                    let mut v964 = C::inst_data_etor_returns::default();
                                                    C::inst_data_etor(ctx, v961.1, &mut v964);
                                                    let mut v964 = v964.into_context_iter();
                                                    while let Some(v965) = v964.next(ctx) {
                                                        if let &InstructionData::IntCompare {
                                                            opcode: ref v968,
                                                            args: ref v969,
                                                            cond: ref v970,
                                                        } = &v965.1 {
                                                            if let &Opcode::Icmp = v968 {
                                                                if v2.0 == v965.0 {
                                                                    let v974 = C::subsume(ctx, v961.1);
                                                                    // Rule at src/opts/icmp.isle line 18.
                                                                    returns.extend(Some(v974));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            0x1_u64 => {
                                                let mut v960 = C::uextend_maybe_etor_returns::default();
                                                C::uextend_maybe_etor(ctx, v256.0, &mut v960);
                                                let mut v960 = v960.into_context_iter();
                                                while let Some(v961) = v960.next(ctx) {
                                                    let mut v964 = C::inst_data_etor_returns::default();
                                                    C::inst_data_etor(ctx, v961.1, &mut v964);
                                                    let mut v964 = v964.into_context_iter();
                                                    while let Some(v965) = v964.next(ctx) {
                                                        if let &InstructionData::IntCompare {
                                                            opcode: ref v968,
                                                            args: ref v969,
                                                            cond: ref v970,
                                                        } = &v965.1 {
                                                            if let &Opcode::Icmp = v968 {
                                                                if v2.0 == v965.0 {
                                                                    let v975 = &C::intcc_complement(ctx, v970);
                                                                    let v971 = C::unpack_value_array_2(ctx, v969);
                                                                    let v976 = constructor_icmp(ctx, v2.0, v975, v971.0, v971.1);
                                                                    let v977 = C::subsume(ctx, v976);
                                                                    // Rule at src/opts/icmp.isle line 32.
                                                                    returns.extend(Some(v977));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                }
                            }
                            if v256.0 == v256.1 {
                                let v52 = C::ty_int(ctx, v2.0);
                                if let Some(v53) = v52 {
                                    let v55 = constructor_iconst_u(ctx, v53, 0x0_u64);
                                    let v56 = C::subsume(ctx, v55);
                                    // Rule at src/opts/icmp.isle line 5.
                                    returns.extend(Some(v56));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                        }
                        &IntCC::SignedGreaterThan => {
                            let v256 = C::unpack_value_array_2(ctx, v254);
                            let mut v915 = C::inst_data_tupled_etor_returns::default();
                            C::inst_data_tupled_etor(ctx, v256.1, &mut v915);
                            let mut v915 = v915.into_context_iter();
                            while let Some(v916) = v915.next(ctx) {
                                let v917 = C::iconst_sextend_etor(ctx, v916);
                                if let Some(v918) = v917 {
                                    match v918.1 {
                                        -1_i64 => {
                                            let v1036 = constructor_iconst_s(ctx, v918.0, 0_i64);
                                            let v1039 = constructor_sge(ctx, v2.0, v256.0, v1036);
                                            // Rule at src/opts/icmp.isle line 167.
                                            returns.extend(Some(v1039));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        0_i64 => {
                                            let mut v593 = C::inst_data_etor_returns::default();
                                            C::inst_data_etor(ctx, v256.0, &mut v593);
                                            let mut v593 = v593.into_context_iter();
                                            while let Some(v594) = v593.next(ctx) {
                                                if v594.0 == I8 {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v1274,
                                                        args: ref v1275,
                                                    } = &v594.1 {
                                                        if let &Opcode::Isub = v1274 {
                                                            let v1276 = C::unpack_value_array_2(ctx, v1275);
                                                            let mut v1279 = C::inst_data_etor_returns::default();
                                                            C::inst_data_etor(ctx, v1276.0, &mut v1279);
                                                            let mut v1279 = v1279.into_context_iter();
                                                            while let Some(v1280) = v1279.next(ctx) {
                                                                if let &InstructionData::IntCompare {
                                                                    opcode: ref v1283,
                                                                    args: ref v1284,
                                                                    cond: ref v1285,
                                                                } = &v1280.1 {
                                                                    if let &Opcode::Icmp = v1283 {
                                                                        match v1285 {
                                                                            &IntCC::SignedGreaterThan => {
                                                                                let mut v1289 = C::inst_data_etor_returns::default();
                                                                                C::inst_data_etor(ctx, v1276.1, &mut v1289);
                                                                                let mut v1289 = v1289.into_context_iter();
                                                                                while let Some(v1290) = v1289.next(ctx) {
                                                                                    if let &InstructionData::IntCompare {
                                                                                        opcode: ref v1293,
                                                                                        args: ref v1294,
                                                                                        cond: ref v1295,
                                                                                    } = &v1290.1 {
                                                                                        if let &Opcode::Icmp = v1293 {
                                                                                            if let &IntCC::SignedLessThan = v1295 {
                                                                                                if v1280.0 == v1290.0 {
                                                                                                    let v1286 = C::unpack_value_array_2(ctx, v1284);
                                                                                                    let v1296 = C::unpack_value_array_2(ctx, v1294);
                                                                                                    if v1286.0 == v1296.0 {
                                                                                                        if v1286.1 == v1296.1 {
                                                                                                            let v1305 = constructor_sgt(ctx, v1280.0, v1286.0, v1286.1);
                                                                                                            // Rule at src/opts/spaceship.isle line 166.
                                                                                                            returns.extend(Some(v1305));
                                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            &IntCC::UnsignedGreaterThan => {
                                                                                let mut v1289 = C::inst_data_etor_returns::default();
                                                                                C::inst_data_etor(ctx, v1276.1, &mut v1289);
                                                                                let mut v1289 = v1289.into_context_iter();
                                                                                while let Some(v1290) = v1289.next(ctx) {
                                                                                    if let &InstructionData::IntCompare {
                                                                                        opcode: ref v1293,
                                                                                        args: ref v1294,
                                                                                        cond: ref v1295,
                                                                                    } = &v1290.1 {
                                                                                        if let &Opcode::Icmp = v1293 {
                                                                                            if let &IntCC::UnsignedLessThan = v1295 {
                                                                                                if v1280.0 == v1290.0 {
                                                                                                    let v1286 = C::unpack_value_array_2(ctx, v1284);
                                                                                                    let v1296 = C::unpack_value_array_2(ctx, v1294);
                                                                                                    if v1286.0 == v1296.0 {
                                                                                                        if v1286.1 == v1296.1 {
                                                                                                            let v1306 = constructor_ugt(ctx, v1280.0, v1286.0, v1286.1);
                                                                                                            // Rule at src/opts/spaceship.isle line 168.
                                                                                                            returns.extend(Some(v1306));
                                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            _ => {}
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                            }
                            let v526 = C::fits_in_64(ctx, v2.0);
                            if let Some(v527) = v526 {
                                let v1005 = C::ty_int(ctx, v527);
                                if let Some(v1006) = v1005 {
                                    let mut v259 = C::inst_data_etor_returns::default();
                                    C::inst_data_etor(ctx, v256.1, &mut v259);
                                    let mut v259 = v259.into_context_iter();
                                    while let Some(v260) = v259.next(ctx) {
                                        if let &InstructionData::UnaryImm {
                                            opcode: ref v263,
                                            imm: v264,
                                        } = &v260.1 {
                                            if let &Opcode::Iconst = v263 {
                                                let v265 = C::u64_from_imm64(ctx, v264);
                                                let v1015 = C::ty_smin(ctx, v260.0);
                                                let v1016 = C::u64_eq(ctx, v265, v1015);
                                                if v1016 == true {
                                                    let v1010 = constructor_ne(ctx, v1006, v256.0, v256.1);
                                                    // Rule at src/opts/icmp.isle line 115.
                                                    returns.extend(Some(v1010));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let v1017 = C::ty_smax(ctx, v260.0);
                                                let v1018 = C::u64_eq(ctx, v265, v1017);
                                                if v1018 == true {
                                                    let v1007 = constructor_iconst_u(ctx, v1006, 0x0_u64);
                                                    let v1008 = C::subsume(ctx, v1007);
                                                    // Rule at src/opts/icmp.isle line 135.
                                                    returns.extend(Some(v1008));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            let v52 = C::ty_int(ctx, v2.0);
                            if let Some(v53) = v52 {
                                if v256.0 == v256.1 {
                                    let v55 = constructor_iconst_u(ctx, v53, 0x0_u64);
                                    let v56 = C::subsume(ctx, v55);
                                    // Rule at src/opts/icmp.isle line 8.
                                    returns.extend(Some(v56));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                        }
                        &IntCC::SignedGreaterThanOrEqual => {
                            let v256 = C::unpack_value_array_2(ctx, v254);
                            let mut v259 = C::inst_data_etor_returns::default();
                            C::inst_data_etor(ctx, v256.1, &mut v259);
                            let mut v259 = v259.into_context_iter();
                            while let Some(v260) = v259.next(ctx) {
                                if let &InstructionData::UnaryImm {
                                    opcode: ref v263,
                                    imm: v264,
                                } = &v260.1 {
                                    if let &Opcode::Iconst = v263 {
                                        let v526 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v527) = v526 {
                                            let v1005 = C::ty_int(ctx, v527);
                                            if let Some(v1006) = v1005 {
                                                let v265 = C::u64_from_imm64(ctx, v264);
                                                let v1015 = C::ty_smin(ctx, v260.0);
                                                let v1016 = C::u64_eq(ctx, v265, v1015);
                                                if v1016 == true {
                                                    let v1011 = constructor_iconst_u(ctx, v1006, 0x1_u64);
                                                    let v1012 = C::subsume(ctx, v1011);
                                                    // Rule at src/opts/icmp.isle line 120.
                                                    returns.extend(Some(v1012));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let v1017 = C::ty_smax(ctx, v260.0);
                                                let v1018 = C::u64_eq(ctx, v265, v1017);
                                                if v1018 == true {
                                                    let v1009 = constructor_eq(ctx, v1006, v256.0, v256.1);
                                                    // Rule at src/opts/icmp.isle line 140.
                                                    returns.extend(Some(v1009));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        let v265 = C::u64_from_imm64(ctx, v264);
                                        if v265 == 0x0_u64 {
                                            let mut v593 = C::inst_data_etor_returns::default();
                                            C::inst_data_etor(ctx, v256.0, &mut v593);
                                            let mut v593 = v593.into_context_iter();
                                            while let Some(v594) = v593.next(ctx) {
                                                if v594.0 == I64 {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v907,
                                                        arg: v908,
                                                    } = &v594.1 {
                                                        if let &Opcode::Uextend = v907 {
                                                            let v909 = C::value_type(ctx, v908);
                                                            if v909 == I32 {
                                                                let v913 = constructor_iconst_u(ctx, v2.0, 0x1_u64);
                                                                let v914 = C::subsume(ctx, v913);
                                                                // Rule at src/opts/extends.isle line 32.
                                                                returns.extend(Some(v914));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            let mut v915 = C::inst_data_tupled_etor_returns::default();
                            C::inst_data_tupled_etor(ctx, v256.1, &mut v915);
                            let mut v915 = v915.into_context_iter();
                            while let Some(v916) = v915.next(ctx) {
                                let v917 = C::iconst_sextend_etor(ctx, v916);
                                if let Some(v918) = v917 {
                                    match v918.1 {
                                        0_i64 => {
                                            let mut v593 = C::inst_data_etor_returns::default();
                                            C::inst_data_etor(ctx, v256.0, &mut v593);
                                            let mut v593 = v593.into_context_iter();
                                            while let Some(v594) = v593.next(ctx) {
                                                if v594.0 == I8 {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v1274,
                                                        args: ref v1275,
                                                    } = &v594.1 {
                                                        if let &Opcode::Isub = v1274 {
                                                            let v1276 = C::unpack_value_array_2(ctx, v1275);
                                                            let mut v1279 = C::inst_data_etor_returns::default();
                                                            C::inst_data_etor(ctx, v1276.0, &mut v1279);
                                                            let mut v1279 = v1279.into_context_iter();
                                                            while let Some(v1280) = v1279.next(ctx) {
                                                                if let &InstructionData::IntCompare {
                                                                    opcode: ref v1283,
                                                                    args: ref v1284,
                                                                    cond: ref v1285,
                                                                } = &v1280.1 {
                                                                    if let &Opcode::Icmp = v1283 {
                                                                        match v1285 {
                                                                            &IntCC::SignedGreaterThan => {
                                                                                let mut v1289 = C::inst_data_etor_returns::default();
                                                                                C::inst_data_etor(ctx, v1276.1, &mut v1289);
                                                                                let mut v1289 = v1289.into_context_iter();
                                                                                while let Some(v1290) = v1289.next(ctx) {
                                                                                    if let &InstructionData::IntCompare {
                                                                                        opcode: ref v1293,
                                                                                        args: ref v1294,
                                                                                        cond: ref v1295,
                                                                                    } = &v1290.1 {
                                                                                        if let &Opcode::Icmp = v1293 {
                                                                                            if let &IntCC::SignedLessThan = v1295 {
                                                                                                if v1280.0 == v1290.0 {
                                                                                                    let v1286 = C::unpack_value_array_2(ctx, v1284);
                                                                                                    let v1296 = C::unpack_value_array_2(ctx, v1294);
                                                                                                    if v1286.0 == v1296.0 {
                                                                                                        if v1286.1 == v1296.1 {
                                                                                                            let v1307 = constructor_sge(ctx, v1280.0, v1286.0, v1286.1);
                                                                                                            // Rule at src/opts/spaceship.isle line 171.
                                                                                                            returns.extend(Some(v1307));
                                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            &IntCC::UnsignedGreaterThan => {
                                                                                let mut v1289 = C::inst_data_etor_returns::default();
                                                                                C::inst_data_etor(ctx, v1276.1, &mut v1289);
                                                                                let mut v1289 = v1289.into_context_iter();
                                                                                while let Some(v1290) = v1289.next(ctx) {
                                                                                    if let &InstructionData::IntCompare {
                                                                                        opcode: ref v1293,
                                                                                        args: ref v1294,
                                                                                        cond: ref v1295,
                                                                                    } = &v1290.1 {
                                                                                        if let &Opcode::Icmp = v1293 {
                                                                                            if let &IntCC::UnsignedLessThan = v1295 {
                                                                                                if v1280.0 == v1290.0 {
                                                                                                    let v1286 = C::unpack_value_array_2(ctx, v1284);
                                                                                                    let v1296 = C::unpack_value_array_2(ctx, v1294);
                                                                                                    if v1286.0 == v1296.0 {
                                                                                                        if v1286.1 == v1296.1 {
                                                                                                            let v1308 = constructor_uge(ctx, v1280.0, v1286.0, v1286.1);
                                                                                                            // Rule at src/opts/spaceship.isle line 173.
                                                                                                            returns.extend(Some(v1308));
                                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            _ => {}
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        1_i64 => {
                                            let v1036 = constructor_iconst_s(ctx, v918.0, 0_i64);
                                            let v1037 = constructor_sgt(ctx, v2.0, v256.0, v1036);
                                            // Rule at src/opts/icmp.isle line 161.
                                            returns.extend(Some(v1037));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        _ => {}
                                    }
                                }
                            }
                            let v52 = C::ty_int(ctx, v2.0);
                            if let Some(v53) = v52 {
                                if v256.0 == v256.1 {
                                    let v958 = constructor_iconst_u(ctx, v53, 0x1_u64);
                                    let v959 = C::subsume(ctx, v958);
                                    // Rule at src/opts/icmp.isle line 9.
                                    returns.extend(Some(v959));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                        }
                        &IntCC::SignedLessThan => {
                            let v256 = C::unpack_value_array_2(ctx, v254);
                            let mut v259 = C::inst_data_etor_returns::default();
                            C::inst_data_etor(ctx, v256.1, &mut v259);
                            let mut v259 = v259.into_context_iter();
                            while let Some(v260) = v259.next(ctx) {
                                if let &InstructionData::UnaryImm {
                                    opcode: ref v263,
                                    imm: v264,
                                } = &v260.1 {
                                    if let &Opcode::Iconst = v263 {
                                        let v526 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v527) = v526 {
                                            let v1005 = C::ty_int(ctx, v527);
                                            if let Some(v1006) = v1005 {
                                                let v265 = C::u64_from_imm64(ctx, v264);
                                                let v1015 = C::ty_smin(ctx, v260.0);
                                                let v1016 = C::u64_eq(ctx, v265, v1015);
                                                if v1016 == true {
                                                    let v1007 = constructor_iconst_u(ctx, v1006, 0x0_u64);
                                                    let v1008 = C::subsume(ctx, v1007);
                                                    // Rule at src/opts/icmp.isle line 105.
                                                    returns.extend(Some(v1008));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let v1017 = C::ty_smax(ctx, v260.0);
                                                let v1018 = C::u64_eq(ctx, v265, v1017);
                                                if v1018 == true {
                                                    let v1010 = constructor_ne(ctx, v1006, v256.0, v256.1);
                                                    // Rule at src/opts/icmp.isle line 125.
                                                    returns.extend(Some(v1010));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        let v265 = C::u64_from_imm64(ctx, v264);
                                        if v265 == 0x0_u64 {
                                            let mut v593 = C::inst_data_etor_returns::default();
                                            C::inst_data_etor(ctx, v256.0, &mut v593);
                                            let mut v593 = v593.into_context_iter();
                                            while let Some(v594) = v593.next(ctx) {
                                                if v594.0 == I64 {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v907,
                                                        arg: v908,
                                                    } = &v594.1 {
                                                        if let &Opcode::Uextend = v907 {
                                                            let v909 = C::value_type(ctx, v908);
                                                            if v909 == I32 {
                                                                let v910 = constructor_iconst_u(ctx, v2.0, 0x0_u64);
                                                                let v911 = C::subsume(ctx, v910);
                                                                // Rule at src/opts/extends.isle line 27.
                                                                returns.extend(Some(v911));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            let mut v915 = C::inst_data_tupled_etor_returns::default();
                            C::inst_data_tupled_etor(ctx, v256.1, &mut v915);
                            let mut v915 = v915.into_context_iter();
                            while let Some(v916) = v915.next(ctx) {
                                let v917 = C::iconst_sextend_etor(ctx, v916);
                                if let Some(v918) = v917 {
                                    match v918.1 {
                                        0_i64 => {
                                            let mut v593 = C::inst_data_etor_returns::default();
                                            C::inst_data_etor(ctx, v256.0, &mut v593);
                                            let mut v593 = v593.into_context_iter();
                                            while let Some(v594) = v593.next(ctx) {
                                                if v594.0 == I8 {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v1274,
                                                        args: ref v1275,
                                                    } = &v594.1 {
                                                        if let &Opcode::Isub = v1274 {
                                                            let v1276 = C::unpack_value_array_2(ctx, v1275);
                                                            let mut v1279 = C::inst_data_etor_returns::default();
                                                            C::inst_data_etor(ctx, v1276.0, &mut v1279);
                                                            let mut v1279 = v1279.into_context_iter();
                                                            while let Some(v1280) = v1279.next(ctx) {
                                                                if let &InstructionData::IntCompare {
                                                                    opcode: ref v1283,
                                                                    args: ref v1284,
                                                                    cond: ref v1285,
                                                                } = &v1280.1 {
                                                                    if let &Opcode::Icmp = v1283 {
                                                                        match v1285 {
                                                                            &IntCC::SignedGreaterThan => {
                                                                                let mut v1289 = C::inst_data_etor_returns::default();
                                                                                C::inst_data_etor(ctx, v1276.1, &mut v1289);
                                                                                let mut v1289 = v1289.into_context_iter();
                                                                                while let Some(v1290) = v1289.next(ctx) {
                                                                                    if let &InstructionData::IntCompare {
                                                                                        opcode: ref v1293,
                                                                                        args: ref v1294,
                                                                                        cond: ref v1295,
                                                                                    } = &v1290.1 {
                                                                                        if let &Opcode::Icmp = v1293 {
                                                                                            if let &IntCC::SignedLessThan = v1295 {
                                                                                                if v1280.0 == v1290.0 {
                                                                                                    let v1286 = C::unpack_value_array_2(ctx, v1284);
                                                                                                    let v1296 = C::unpack_value_array_2(ctx, v1294);
                                                                                                    if v1286.0 == v1296.0 {
                                                                                                        if v1286.1 == v1296.1 {
                                                                                                            let v1301 = constructor_slt(ctx, v1280.0, v1286.0, v1286.1);
                                                                                                            // Rule at src/opts/spaceship.isle line 156.
                                                                                                            returns.extend(Some(v1301));
                                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            &IntCC::UnsignedGreaterThan => {
                                                                                let mut v1289 = C::inst_data_etor_returns::default();
                                                                                C::inst_data_etor(ctx, v1276.1, &mut v1289);
                                                                                let mut v1289 = v1289.into_context_iter();
                                                                                while let Some(v1290) = v1289.next(ctx) {
                                                                                    if let &InstructionData::IntCompare {
                                                                                        opcode: ref v1293,
                                                                                        args: ref v1294,
                                                                                        cond: ref v1295,
                                                                                    } = &v1290.1 {
                                                                                        if let &Opcode::Icmp = v1293 {
                                                                                            if let &IntCC::UnsignedLessThan = v1295 {
                                                                                                if v1280.0 == v1290.0 {
                                                                                                    let v1286 = C::unpack_value_array_2(ctx, v1284);
                                                                                                    let v1296 = C::unpack_value_array_2(ctx, v1294);
                                                                                                    if v1286.0 == v1296.0 {
                                                                                                        if v1286.1 == v1296.1 {
                                                                                                            let v1302 = constructor_ult(ctx, v1280.0, v1286.0, v1286.1);
                                                                                                            // Rule at src/opts/spaceship.isle line 158.
                                                                                                            returns.extend(Some(v1302));
                                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            _ => {}
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        1_i64 => {
                                            let v1036 = constructor_iconst_s(ctx, v918.0, 0_i64);
                                            let v1038 = constructor_sle(ctx, v2.0, v256.0, v1036);
                                            // Rule at src/opts/icmp.isle line 164.
                                            returns.extend(Some(v1038));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        _ => {}
                                    }
                                }
                            }
                            let v52 = C::ty_int(ctx, v2.0);
                            if let Some(v53) = v52 {
                                if v256.0 == v256.1 {
                                    let v55 = constructor_iconst_u(ctx, v53, 0x0_u64);
                                    let v56 = C::subsume(ctx, v55);
                                    // Rule at src/opts/icmp.isle line 12.
                                    returns.extend(Some(v56));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                        }
                        &IntCC::SignedLessThanOrEqual => {
                            let v256 = C::unpack_value_array_2(ctx, v254);
                            let mut v915 = C::inst_data_tupled_etor_returns::default();
                            C::inst_data_tupled_etor(ctx, v256.1, &mut v915);
                            let mut v915 = v915.into_context_iter();
                            while let Some(v916) = v915.next(ctx) {
                                let v917 = C::iconst_sextend_etor(ctx, v916);
                                if let Some(v918) = v917 {
                                    match v918.1 {
                                        -1_i64 => {
                                            let v1036 = constructor_iconst_s(ctx, v918.0, 0_i64);
                                            let v1040 = constructor_slt(ctx, v2.0, v256.0, v1036);
                                            // Rule at src/opts/icmp.isle line 170.
                                            returns.extend(Some(v1040));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        0_i64 => {
                                            let mut v593 = C::inst_data_etor_returns::default();
                                            C::inst_data_etor(ctx, v256.0, &mut v593);
                                            let mut v593 = v593.into_context_iter();
                                            while let Some(v594) = v593.next(ctx) {
                                                if v594.0 == I8 {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v1274,
                                                        args: ref v1275,
                                                    } = &v594.1 {
                                                        if let &Opcode::Isub = v1274 {
                                                            let v1276 = C::unpack_value_array_2(ctx, v1275);
                                                            let mut v1279 = C::inst_data_etor_returns::default();
                                                            C::inst_data_etor(ctx, v1276.0, &mut v1279);
                                                            let mut v1279 = v1279.into_context_iter();
                                                            while let Some(v1280) = v1279.next(ctx) {
                                                                if let &InstructionData::IntCompare {
                                                                    opcode: ref v1283,
                                                                    args: ref v1284,
                                                                    cond: ref v1285,
                                                                } = &v1280.1 {
                                                                    if let &Opcode::Icmp = v1283 {
                                                                        match v1285 {
                                                                            &IntCC::SignedGreaterThan => {
                                                                                let mut v1289 = C::inst_data_etor_returns::default();
                                                                                C::inst_data_etor(ctx, v1276.1, &mut v1289);
                                                                                let mut v1289 = v1289.into_context_iter();
                                                                                while let Some(v1290) = v1289.next(ctx) {
                                                                                    if let &InstructionData::IntCompare {
                                                                                        opcode: ref v1293,
                                                                                        args: ref v1294,
                                                                                        cond: ref v1295,
                                                                                    } = &v1290.1 {
                                                                                        if let &Opcode::Icmp = v1293 {
                                                                                            if let &IntCC::SignedLessThan = v1295 {
                                                                                                if v1280.0 == v1290.0 {
                                                                                                    let v1286 = C::unpack_value_array_2(ctx, v1284);
                                                                                                    let v1296 = C::unpack_value_array_2(ctx, v1294);
                                                                                                    if v1286.0 == v1296.0 {
                                                                                                        if v1286.1 == v1296.1 {
                                                                                                            let v1303 = constructor_sle(ctx, v1280.0, v1286.0, v1286.1);
                                                                                                            // Rule at src/opts/spaceship.isle line 161.
                                                                                                            returns.extend(Some(v1303));
                                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            &IntCC::UnsignedGreaterThan => {
                                                                                let mut v1289 = C::inst_data_etor_returns::default();
                                                                                C::inst_data_etor(ctx, v1276.1, &mut v1289);
                                                                                let mut v1289 = v1289.into_context_iter();
                                                                                while let Some(v1290) = v1289.next(ctx) {
                                                                                    if let &InstructionData::IntCompare {
                                                                                        opcode: ref v1293,
                                                                                        args: ref v1294,
                                                                                        cond: ref v1295,
                                                                                    } = &v1290.1 {
                                                                                        if let &Opcode::Icmp = v1293 {
                                                                                            if let &IntCC::UnsignedLessThan = v1295 {
                                                                                                if v1280.0 == v1290.0 {
                                                                                                    let v1286 = C::unpack_value_array_2(ctx, v1284);
                                                                                                    let v1296 = C::unpack_value_array_2(ctx, v1294);
                                                                                                    if v1286.0 == v1296.0 {
                                                                                                        if v1286.1 == v1296.1 {
                                                                                                            let v1304 = constructor_ule(ctx, v1280.0, v1286.0, v1286.1);
                                                                                                            // Rule at src/opts/spaceship.isle line 163.
                                                                                                            returns.extend(Some(v1304));
                                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            _ => {}
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                            }
                            let v526 = C::fits_in_64(ctx, v2.0);
                            if let Some(v527) = v526 {
                                let v1005 = C::ty_int(ctx, v527);
                                if let Some(v1006) = v1005 {
                                    let mut v259 = C::inst_data_etor_returns::default();
                                    C::inst_data_etor(ctx, v256.1, &mut v259);
                                    let mut v259 = v259.into_context_iter();
                                    while let Some(v260) = v259.next(ctx) {
                                        if let &InstructionData::UnaryImm {
                                            opcode: ref v263,
                                            imm: v264,
                                        } = &v260.1 {
                                            if let &Opcode::Iconst = v263 {
                                                let v265 = C::u64_from_imm64(ctx, v264);
                                                let v1015 = C::ty_smin(ctx, v260.0);
                                                let v1016 = C::u64_eq(ctx, v265, v1015);
                                                if v1016 == true {
                                                    let v1009 = constructor_eq(ctx, v1006, v256.0, v256.1);
                                                    // Rule at src/opts/icmp.isle line 110.
                                                    returns.extend(Some(v1009));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let v1017 = C::ty_smax(ctx, v260.0);
                                                let v1018 = C::u64_eq(ctx, v265, v1017);
                                                if v1018 == true {
                                                    let v1011 = constructor_iconst_u(ctx, v1006, 0x1_u64);
                                                    let v1012 = C::subsume(ctx, v1011);
                                                    // Rule at src/opts/icmp.isle line 130.
                                                    returns.extend(Some(v1012));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            let v52 = C::ty_int(ctx, v2.0);
                            if let Some(v53) = v52 {
                                if v256.0 == v256.1 {
                                    let v958 = constructor_iconst_u(ctx, v53, 0x1_u64);
                                    let v959 = C::subsume(ctx, v958);
                                    // Rule at src/opts/icmp.isle line 13.
                                    returns.extend(Some(v959));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                        }
                        &IntCC::UnsignedGreaterThan => {
                            let v526 = C::fits_in_64(ctx, v2.0);
                            if let Some(v527) = v526 {
                                let v1005 = C::ty_int(ctx, v527);
                                if let Some(v1006) = v1005 {
                                    let v256 = C::unpack_value_array_2(ctx, v254);
                                    let mut v259 = C::inst_data_etor_returns::default();
                                    C::inst_data_etor(ctx, v256.1, &mut v259);
                                    let mut v259 = v259.into_context_iter();
                                    while let Some(v260) = v259.next(ctx) {
                                        if let &InstructionData::UnaryImm {
                                            opcode: ref v263,
                                            imm: v264,
                                        } = &v260.1 {
                                            if let &Opcode::Iconst = v263 {
                                                let v265 = C::u64_from_imm64(ctx, v264);
                                                if v265 == 0x0_u64 {
                                                    let v1010 = constructor_ne(ctx, v1006, v256.0, v256.1);
                                                    // Rule at src/opts/icmp.isle line 77.
                                                    returns.extend(Some(v1010));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let v1013 = C::ty_umax(ctx, v260.0);
                                                let v1014 = C::u64_eq(ctx, v265, v1013);
                                                if v1014 == true {
                                                    let v1007 = constructor_iconst_u(ctx, v1006, 0x0_u64);
                                                    let v1008 = C::subsume(ctx, v1007);
                                                    // Rule at src/opts/icmp.isle line 95.
                                                    returns.extend(Some(v1008));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            let v52 = C::ty_int(ctx, v2.0);
                            if let Some(v53) = v52 {
                                let v256 = C::unpack_value_array_2(ctx, v254);
                                if v256.0 == v256.1 {
                                    let v55 = constructor_iconst_u(ctx, v53, 0x0_u64);
                                    let v56 = C::subsume(ctx, v55);
                                    // Rule at src/opts/icmp.isle line 6.
                                    returns.extend(Some(v56));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                        }
                        &IntCC::UnsignedGreaterThanOrEqual => {
                            let v256 = C::unpack_value_array_2(ctx, v254);
                            let mut v259 = C::inst_data_etor_returns::default();
                            C::inst_data_etor(ctx, v256.1, &mut v259);
                            let mut v259 = v259.into_context_iter();
                            while let Some(v260) = v259.next(ctx) {
                                if let &InstructionData::UnaryImm {
                                    opcode: ref v263,
                                    imm: v264,
                                } = &v260.1 {
                                    if let &Opcode::Iconst = v263 {
                                        let v265 = C::u64_from_imm64(ctx, v264);
                                        match v265 {
                                            0x0_u64 => {
                                                let v526 = C::fits_in_64(ctx, v2.0);
                                                if let Some(v527) = v526 {
                                                    let v1005 = C::ty_int(ctx, v527);
                                                    if let Some(v1006) = v1005 {
                                                        let v1011 = constructor_iconst_u(ctx, v1006, 0x1_u64);
                                                        let v1012 = C::subsume(ctx, v1011);
                                                        // Rule at src/opts/icmp.isle line 81.
                                                        returns.extend(Some(v1012));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            0x1_u64 => {
                                                let v1033 = constructor_iconst_u(ctx, v260.0, 0x0_u64);
                                                let v1034 = constructor_ne(ctx, v2.0, v256.0, v1033);
                                                // Rule at src/opts/icmp.isle line 155.
                                                returns.extend(Some(v1034));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            _ => {}
                                        }
                                        let v526 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v527) = v526 {
                                            let v1005 = C::ty_int(ctx, v527);
                                            if let Some(v1006) = v1005 {
                                                let v1013 = C::ty_umax(ctx, v260.0);
                                                let v1014 = C::u64_eq(ctx, v265, v1013);
                                                if v1014 == true {
                                                    let v1009 = constructor_eq(ctx, v1006, v256.0, v256.1);
                                                    // Rule at src/opts/icmp.isle line 100.
                                                    returns.extend(Some(v1009));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            let v52 = C::ty_int(ctx, v2.0);
                            if let Some(v53) = v52 {
                                if v256.0 == v256.1 {
                                    let v958 = constructor_iconst_u(ctx, v53, 0x1_u64);
                                    let v959 = C::subsume(ctx, v958);
                                    // Rule at src/opts/icmp.isle line 7.
                                    returns.extend(Some(v959));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                        }
                        &IntCC::UnsignedLessThan => {
                            let v256 = C::unpack_value_array_2(ctx, v254);
                            let mut v259 = C::inst_data_etor_returns::default();
                            C::inst_data_etor(ctx, v256.1, &mut v259);
                            let mut v259 = v259.into_context_iter();
                            while let Some(v260) = v259.next(ctx) {
                                if let &InstructionData::UnaryImm {
                                    opcode: ref v263,
                                    imm: v264,
                                } = &v260.1 {
                                    if let &Opcode::Iconst = v263 {
                                        let v265 = C::u64_from_imm64(ctx, v264);
                                        match v265 {
                                            0x0_u64 => {
                                                let v526 = C::fits_in_64(ctx, v2.0);
                                                if let Some(v527) = v526 {
                                                    let v1005 = C::ty_int(ctx, v527);
                                                    if let Some(v1006) = v1005 {
                                                        let v1007 = constructor_iconst_u(ctx, v1006, 0x0_u64);
                                                        let v1008 = C::subsume(ctx, v1007);
                                                        // Rule at src/opts/icmp.isle line 69.
                                                        returns.extend(Some(v1008));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            0x1_u64 => {
                                                let v1033 = constructor_iconst_u(ctx, v260.0, 0x0_u64);
                                                let v1035 = constructor_eq(ctx, v2.0, v256.0, v1033);
                                                // Rule at src/opts/icmp.isle line 158.
                                                returns.extend(Some(v1035));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            _ => {}
                                        }
                                        let v526 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v527) = v526 {
                                            let v1005 = C::ty_int(ctx, v527);
                                            if let Some(v1006) = v1005 {
                                                let v1013 = C::ty_umax(ctx, v260.0);
                                                let v1014 = C::u64_eq(ctx, v265, v1013);
                                                if v1014 == true {
                                                    let v1010 = constructor_ne(ctx, v1006, v256.0, v256.1);
                                                    // Rule at src/opts/icmp.isle line 85.
                                                    returns.extend(Some(v1010));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            let v52 = C::ty_int(ctx, v2.0);
                            if let Some(v53) = v52 {
                                if v256.0 == v256.1 {
                                    let v55 = constructor_iconst_u(ctx, v53, 0x0_u64);
                                    let v56 = C::subsume(ctx, v55);
                                    // Rule at src/opts/icmp.isle line 10.
                                    returns.extend(Some(v56));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                        }
                        &IntCC::UnsignedLessThanOrEqual => {
                            let v526 = C::fits_in_64(ctx, v2.0);
                            if let Some(v527) = v526 {
                                let v1005 = C::ty_int(ctx, v527);
                                if let Some(v1006) = v1005 {
                                    let v256 = C::unpack_value_array_2(ctx, v254);
                                    let mut v259 = C::inst_data_etor_returns::default();
                                    C::inst_data_etor(ctx, v256.1, &mut v259);
                                    let mut v259 = v259.into_context_iter();
                                    while let Some(v260) = v259.next(ctx) {
                                        if let &InstructionData::UnaryImm {
                                            opcode: ref v263,
                                            imm: v264,
                                        } = &v260.1 {
                                            if let &Opcode::Iconst = v263 {
                                                let v265 = C::u64_from_imm64(ctx, v264);
                                                if v265 == 0x0_u64 {
                                                    let v1009 = constructor_eq(ctx, v1006, v256.0, v256.1);
                                                    // Rule at src/opts/icmp.isle line 73.
                                                    returns.extend(Some(v1009));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let v1013 = C::ty_umax(ctx, v260.0);
                                                let v1014 = C::u64_eq(ctx, v265, v1013);
                                                if v1014 == true {
                                                    let v1011 = constructor_iconst_u(ctx, v1006, 0x1_u64);
                                                    let v1012 = C::subsume(ctx, v1011);
                                                    // Rule at src/opts/icmp.isle line 90.
                                                    returns.extend(Some(v1012));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            let v52 = C::ty_int(ctx, v2.0);
                            if let Some(v53) = v52 {
                                let v256 = C::unpack_value_array_2(ctx, v254);
                                if v256.0 == v256.1 {
                                    let v958 = constructor_iconst_u(ctx, v53, 0x1_u64);
                                    let v959 = C::subsume(ctx, v958);
                                    // Rule at src/opts/icmp.isle line 11.
                                    returns.extend(Some(v959));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                        }
                        _ => {}
                    }
                    let v256 = C::unpack_value_array_2(ctx, v254);
                    let mut v593 = C::inst_data_etor_returns::default();
                    C::inst_data_etor(ctx, v256.0, &mut v593);
                    let mut v593 = v593.into_context_iter();
                    while let Some(v594) = v593.next(ctx) {
                        match &v594.1 {
                            &InstructionData::Unary {
                                opcode: ref v907,
                                arg: v908,
                            } => {
                                if let &Opcode::Sextend = v907 {
                                    let v925 = &C::signed_cond_code(ctx, v255);
                                    if let Some(v926) = v925 {
                                        let mut v915 = C::inst_data_tupled_etor_returns::default();
                                        C::inst_data_tupled_etor(ctx, v256.1, &mut v915);
                                        let mut v915 = v915.into_context_iter();
                                        while let Some(v916) = v915.next(ctx) {
                                            let v917 = C::iconst_sextend_etor(ctx, v916);
                                            if let Some(v918) = v917 {
                                                if v918.1 == 0_i64 {
                                                    let v909 = C::value_type(ctx, v908);
                                                    let v922 = constructor_iconst_s(ctx, v909, 0_i64);
                                                    let v927 = constructor_icmp(ctx, v909, v255, v908, v922);
                                                    // Rule at src/opts/extends.isle line 43.
                                                    returns.extend(Some(v927));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            &InstructionData::UnaryImm {
                                opcode: ref v597,
                                imm: v598,
                            } => {
                                if let &Opcode::Iconst = v597 {
                                    let mut v259 = C::inst_data_etor_returns::default();
                                    C::inst_data_etor(ctx, v256.1, &mut v259);
                                    let mut v259 = v259.into_context_iter();
                                    while let Some(v260) = v259.next(ctx) {
                                        if let &InstructionData::UnaryImm {
                                            opcode: ref v263,
                                            imm: v264,
                                        } = &v260.1 {
                                            if let &Opcode::Iconst = v263 {
                                                if v260.0 == v594.0 {
                                                    let v599 = C::imm64_icmp(ctx, v594.0, v255, v598, v264);
                                                    let v600 = constructor_iconst(ctx, v2.0, v599);
                                                    let v601 = C::subsume(ctx, v600);
                                                    // Rule at src/opts/cprop.isle line 82.
                                                    returns.extend(Some(v601));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                    let v609 = &C::intcc_swap_args(ctx, v255);
                                    let v610 = constructor_icmp(ctx, v2.0, v609, v256.1, v256.0);
                                    // Rule at src/opts/cprop.isle line 116.
                                    returns.extend(Some(v610));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                            _ => {}
                        }
                    }
                }
            }
            &InstructionData::Ternary {
                opcode: ref v84,
                args: ref v85,
            } => {
                match v84 {
                    &Opcode::Select => {
                        let v86 = C::unpack_value_array_3(ctx, v85);
                        let mut v90 = C::inst_data_etor_returns::default();
                        C::inst_data_etor(ctx, v86.0, &mut v90);
                        let mut v90 = v90.into_context_iter();
                        while let Some(v91) = v90.next(ctx) {
                            match &v91.1 {
                                &InstructionData::IntCompare {
                                    opcode: ref v1041,
                                    args: ref v1042,
                                    cond: ref v1043,
                                } => {
                                    if let &Opcode::Icmp = v1041 {
                                        match v1043 {
                                            &IntCC::Equal => {
                                                let mut v1057 = C::inst_data_etor_returns::default();
                                                C::inst_data_etor(ctx, v86.2, &mut v1057);
                                                let mut v1057 = v1057.into_context_iter();
                                                while let Some(v1058) = v1057.next(ctx) {
                                                    match &v1058.1 {
                                                        &InstructionData::IntCompare {
                                                            opcode: ref v1061,
                                                            args: ref v1062,
                                                            cond: ref v1063,
                                                        } => {
                                                            if let &Opcode::Icmp = v1061 {
                                                                match v1063 {
                                                                    &IntCC::SignedGreaterThan => {
                                                                        let v1044 = C::unpack_value_array_2(ctx, v1042);
                                                                        let v1047 = C::value_type(ctx, v1044.0);
                                                                        if v1047 == I64 {
                                                                            let v1048 = C::value_type(ctx, v1044.1);
                                                                            if v1048 == I64 {
                                                                                if v2.0 == v1058.0 {
                                                                                    let v1064 = C::unpack_value_array_2(ctx, v1062);
                                                                                    if v1044.0 == v1064.0 {
                                                                                        if v1044.1 == v1064.1 {
                                                                                            let mut v96 = C::inst_data_etor_returns::default();
                                                                                            C::inst_data_etor(ctx, v86.1, &mut v96);
                                                                                            let mut v96 = v96.into_context_iter();
                                                                                            while let Some(v97) = v96.next(ctx) {
                                                                                                if let &InstructionData::IntCompare {
                                                                                                    opcode: ref v1049,
                                                                                                    args: ref v1050,
                                                                                                    cond: ref v1051,
                                                                                                } = &v97.1 {
                                                                                                    if let &Opcode::Icmp = v1049 {
                                                                                                        if let &IntCC::UnsignedGreaterThan = v1051 {
                                                                                                            let v1052 = C::unpack_value_array_2(ctx, v1050);
                                                                                                            let v1055 = C::value_type(ctx, v1052.0);
                                                                                                            if v1055 == I64 {
                                                                                                                let v1056 = C::value_type(ctx, v1052.1);
                                                                                                                if v1056 == I64 {
                                                                                                                    if v2.0 == v97.0 {
                                                                                                                        let v1067 = constructor_iconcat(ctx, I64, v1052.0, v1044.0);
                                                                                                                        let v1068 = constructor_iconcat(ctx, I64, v1052.1, v1044.1);
                                                                                                                        let v1072 = constructor_sgt(ctx, v2.0, v1067, v1068);
                                                                                                                        // Rule at src/opts/icmp.isle line 234.
                                                                                                                        returns.extend(Some(v1072));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedGreaterThanOrEqual => {
                                                                        let v1044 = C::unpack_value_array_2(ctx, v1042);
                                                                        let v1047 = C::value_type(ctx, v1044.0);
                                                                        if v1047 == I64 {
                                                                            let v1048 = C::value_type(ctx, v1044.1);
                                                                            if v1048 == I64 {
                                                                                if v2.0 == v1058.0 {
                                                                                    let v1064 = C::unpack_value_array_2(ctx, v1062);
                                                                                    if v1044.0 == v1064.0 {
                                                                                        if v1044.1 == v1064.1 {
                                                                                            let mut v96 = C::inst_data_etor_returns::default();
                                                                                            C::inst_data_etor(ctx, v86.1, &mut v96);
                                                                                            let mut v96 = v96.into_context_iter();
                                                                                            while let Some(v97) = v96.next(ctx) {
                                                                                                if let &InstructionData::IntCompare {
                                                                                                    opcode: ref v1049,
                                                                                                    args: ref v1050,
                                                                                                    cond: ref v1051,
                                                                                                } = &v97.1 {
                                                                                                    if let &Opcode::Icmp = v1049 {
                                                                                                        if let &IntCC::UnsignedGreaterThanOrEqual = v1051 {
                                                                                                            let v1052 = C::unpack_value_array_2(ctx, v1050);
                                                                                                            let v1055 = C::value_type(ctx, v1052.0);
                                                                                                            if v1055 == I64 {
                                                                                                                let v1056 = C::value_type(ctx, v1052.1);
                                                                                                                if v1056 == I64 {
                                                                                                                    if v2.0 == v97.0 {
                                                                                                                        let v1067 = constructor_iconcat(ctx, I64, v1052.0, v1044.0);
                                                                                                                        let v1068 = constructor_iconcat(ctx, I64, v1052.1, v1044.1);
                                                                                                                        let v1070 = constructor_sge(ctx, v2.0, v1067, v1068);
                                                                                                                        // Rule at src/opts/icmp.isle line 224.
                                                                                                                        returns.extend(Some(v1070));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedLessThan => {
                                                                        let v1044 = C::unpack_value_array_2(ctx, v1042);
                                                                        let v1047 = C::value_type(ctx, v1044.0);
                                                                        if v1047 == I64 {
                                                                            let v1048 = C::value_type(ctx, v1044.1);
                                                                            if v1048 == I64 {
                                                                                if v2.0 == v1058.0 {
                                                                                    let v1064 = C::unpack_value_array_2(ctx, v1062);
                                                                                    if v1044.0 == v1064.0 {
                                                                                        if v1044.1 == v1064.1 {
                                                                                            let mut v96 = C::inst_data_etor_returns::default();
                                                                                            C::inst_data_etor(ctx, v86.1, &mut v96);
                                                                                            let mut v96 = v96.into_context_iter();
                                                                                            while let Some(v97) = v96.next(ctx) {
                                                                                                if let &InstructionData::IntCompare {
                                                                                                    opcode: ref v1049,
                                                                                                    args: ref v1050,
                                                                                                    cond: ref v1051,
                                                                                                } = &v97.1 {
                                                                                                    if let &Opcode::Icmp = v1049 {
                                                                                                        if let &IntCC::UnsignedLessThan = v1051 {
                                                                                                            let v1052 = C::unpack_value_array_2(ctx, v1050);
                                                                                                            let v1055 = C::value_type(ctx, v1052.0);
                                                                                                            if v1055 == I64 {
                                                                                                                let v1056 = C::value_type(ctx, v1052.1);
                                                                                                                if v1056 == I64 {
                                                                                                                    if v2.0 == v97.0 {
                                                                                                                        let v1067 = constructor_iconcat(ctx, I64, v1052.0, v1044.0);
                                                                                                                        let v1068 = constructor_iconcat(ctx, I64, v1052.1, v1044.1);
                                                                                                                        let v1076 = constructor_slt(ctx, v2.0, v1067, v1068);
                                                                                                                        // Rule at src/opts/icmp.isle line 254.
                                                                                                                        returns.extend(Some(v1076));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedLessThanOrEqual => {
                                                                        let v1044 = C::unpack_value_array_2(ctx, v1042);
                                                                        let v1047 = C::value_type(ctx, v1044.0);
                                                                        if v1047 == I64 {
                                                                            let v1048 = C::value_type(ctx, v1044.1);
                                                                            if v1048 == I64 {
                                                                                if v2.0 == v1058.0 {
                                                                                    let v1064 = C::unpack_value_array_2(ctx, v1062);
                                                                                    if v1044.0 == v1064.0 {
                                                                                        if v1044.1 == v1064.1 {
                                                                                            let mut v96 = C::inst_data_etor_returns::default();
                                                                                            C::inst_data_etor(ctx, v86.1, &mut v96);
                                                                                            let mut v96 = v96.into_context_iter();
                                                                                            while let Some(v97) = v96.next(ctx) {
                                                                                                if let &InstructionData::IntCompare {
                                                                                                    opcode: ref v1049,
                                                                                                    args: ref v1050,
                                                                                                    cond: ref v1051,
                                                                                                } = &v97.1 {
                                                                                                    if let &Opcode::Icmp = v1049 {
                                                                                                        if let &IntCC::UnsignedLessThanOrEqual = v1051 {
                                                                                                            let v1052 = C::unpack_value_array_2(ctx, v1050);
                                                                                                            let v1055 = C::value_type(ctx, v1052.0);
                                                                                                            if v1055 == I64 {
                                                                                                                let v1056 = C::value_type(ctx, v1052.1);
                                                                                                                if v1056 == I64 {
                                                                                                                    if v2.0 == v97.0 {
                                                                                                                        let v1067 = constructor_iconcat(ctx, I64, v1052.0, v1044.0);
                                                                                                                        let v1068 = constructor_iconcat(ctx, I64, v1052.1, v1044.1);
                                                                                                                        let v1074 = constructor_sle(ctx, v2.0, v1067, v1068);
                                                                                                                        // Rule at src/opts/icmp.isle line 244.
                                                                                                                        returns.extend(Some(v1074));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedGreaterThan => {
                                                                        let v1044 = C::unpack_value_array_2(ctx, v1042);
                                                                        let v1047 = C::value_type(ctx, v1044.0);
                                                                        if v1047 == I64 {
                                                                            let v1048 = C::value_type(ctx, v1044.1);
                                                                            if v1048 == I64 {
                                                                                if v2.0 == v1058.0 {
                                                                                    let v1064 = C::unpack_value_array_2(ctx, v1062);
                                                                                    if v1044.0 == v1064.0 {
                                                                                        if v1044.1 == v1064.1 {
                                                                                            let mut v96 = C::inst_data_etor_returns::default();
                                                                                            C::inst_data_etor(ctx, v86.1, &mut v96);
                                                                                            let mut v96 = v96.into_context_iter();
                                                                                            while let Some(v97) = v96.next(ctx) {
                                                                                                if let &InstructionData::IntCompare {
                                                                                                    opcode: ref v1049,
                                                                                                    args: ref v1050,
                                                                                                    cond: ref v1051,
                                                                                                } = &v97.1 {
                                                                                                    if let &Opcode::Icmp = v1049 {
                                                                                                        if let &IntCC::UnsignedGreaterThan = v1051 {
                                                                                                            let v1052 = C::unpack_value_array_2(ctx, v1050);
                                                                                                            let v1055 = C::value_type(ctx, v1052.0);
                                                                                                            if v1055 == I64 {
                                                                                                                let v1056 = C::value_type(ctx, v1052.1);
                                                                                                                if v1056 == I64 {
                                                                                                                    if v2.0 == v97.0 {
                                                                                                                        let v1067 = constructor_iconcat(ctx, I64, v1052.0, v1044.0);
                                                                                                                        let v1068 = constructor_iconcat(ctx, I64, v1052.1, v1044.1);
                                                                                                                        let v1071 = constructor_ugt(ctx, v2.0, v1067, v1068);
                                                                                                                        // Rule at src/opts/icmp.isle line 229.
                                                                                                                        returns.extend(Some(v1071));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedGreaterThanOrEqual => {
                                                                        let v1044 = C::unpack_value_array_2(ctx, v1042);
                                                                        let v1047 = C::value_type(ctx, v1044.0);
                                                                        if v1047 == I64 {
                                                                            let v1048 = C::value_type(ctx, v1044.1);
                                                                            if v1048 == I64 {
                                                                                if v2.0 == v1058.0 {
                                                                                    let v1064 = C::unpack_value_array_2(ctx, v1062);
                                                                                    if v1044.0 == v1064.0 {
                                                                                        if v1044.1 == v1064.1 {
                                                                                            let mut v96 = C::inst_data_etor_returns::default();
                                                                                            C::inst_data_etor(ctx, v86.1, &mut v96);
                                                                                            let mut v96 = v96.into_context_iter();
                                                                                            while let Some(v97) = v96.next(ctx) {
                                                                                                if let &InstructionData::IntCompare {
                                                                                                    opcode: ref v1049,
                                                                                                    args: ref v1050,
                                                                                                    cond: ref v1051,
                                                                                                } = &v97.1 {
                                                                                                    if let &Opcode::Icmp = v1049 {
                                                                                                        if let &IntCC::UnsignedGreaterThanOrEqual = v1051 {
                                                                                                            let v1052 = C::unpack_value_array_2(ctx, v1050);
                                                                                                            let v1055 = C::value_type(ctx, v1052.0);
                                                                                                            if v1055 == I64 {
                                                                                                                let v1056 = C::value_type(ctx, v1052.1);
                                                                                                                if v1056 == I64 {
                                                                                                                    if v2.0 == v97.0 {
                                                                                                                        let v1067 = constructor_iconcat(ctx, I64, v1052.0, v1044.0);
                                                                                                                        let v1068 = constructor_iconcat(ctx, I64, v1052.1, v1044.1);
                                                                                                                        let v1069 = constructor_uge(ctx, v2.0, v1067, v1068);
                                                                                                                        // Rule at src/opts/icmp.isle line 219.
                                                                                                                        returns.extend(Some(v1069));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        let v1044 = C::unpack_value_array_2(ctx, v1042);
                                                                        let v1047 = C::value_type(ctx, v1044.0);
                                                                        if v1047 == I64 {
                                                                            let v1048 = C::value_type(ctx, v1044.1);
                                                                            if v1048 == I64 {
                                                                                if v2.0 == v1058.0 {
                                                                                    let v1064 = C::unpack_value_array_2(ctx, v1062);
                                                                                    if v1044.0 == v1064.0 {
                                                                                        if v1044.1 == v1064.1 {
                                                                                            let mut v96 = C::inst_data_etor_returns::default();
                                                                                            C::inst_data_etor(ctx, v86.1, &mut v96);
                                                                                            let mut v96 = v96.into_context_iter();
                                                                                            while let Some(v97) = v96.next(ctx) {
                                                                                                if let &InstructionData::IntCompare {
                                                                                                    opcode: ref v1049,
                                                                                                    args: ref v1050,
                                                                                                    cond: ref v1051,
                                                                                                } = &v97.1 {
                                                                                                    if let &Opcode::Icmp = v1049 {
                                                                                                        if let &IntCC::UnsignedLessThan = v1051 {
                                                                                                            let v1052 = C::unpack_value_array_2(ctx, v1050);
                                                                                                            let v1055 = C::value_type(ctx, v1052.0);
                                                                                                            if v1055 == I64 {
                                                                                                                let v1056 = C::value_type(ctx, v1052.1);
                                                                                                                if v1056 == I64 {
                                                                                                                    if v2.0 == v97.0 {
                                                                                                                        let v1067 = constructor_iconcat(ctx, I64, v1052.0, v1044.0);
                                                                                                                        let v1068 = constructor_iconcat(ctx, I64, v1052.1, v1044.1);
                                                                                                                        let v1075 = constructor_ult(ctx, v2.0, v1067, v1068);
                                                                                                                        // Rule at src/opts/icmp.isle line 249.
                                                                                                                        returns.extend(Some(v1075));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThanOrEqual => {
                                                                        let v1044 = C::unpack_value_array_2(ctx, v1042);
                                                                        let v1047 = C::value_type(ctx, v1044.0);
                                                                        if v1047 == I64 {
                                                                            let v1048 = C::value_type(ctx, v1044.1);
                                                                            if v1048 == I64 {
                                                                                if v2.0 == v1058.0 {
                                                                                    let v1064 = C::unpack_value_array_2(ctx, v1062);
                                                                                    if v1044.0 == v1064.0 {
                                                                                        if v1044.1 == v1064.1 {
                                                                                            let mut v96 = C::inst_data_etor_returns::default();
                                                                                            C::inst_data_etor(ctx, v86.1, &mut v96);
                                                                                            let mut v96 = v96.into_context_iter();
                                                                                            while let Some(v97) = v96.next(ctx) {
                                                                                                if let &InstructionData::IntCompare {
                                                                                                    opcode: ref v1049,
                                                                                                    args: ref v1050,
                                                                                                    cond: ref v1051,
                                                                                                } = &v97.1 {
                                                                                                    if let &Opcode::Icmp = v1049 {
                                                                                                        if let &IntCC::UnsignedLessThanOrEqual = v1051 {
                                                                                                            let v1052 = C::unpack_value_array_2(ctx, v1050);
                                                                                                            let v1055 = C::value_type(ctx, v1052.0);
                                                                                                            if v1055 == I64 {
                                                                                                                let v1056 = C::value_type(ctx, v1052.1);
                                                                                                                if v1056 == I64 {
                                                                                                                    if v2.0 == v97.0 {
                                                                                                                        let v1067 = constructor_iconcat(ctx, I64, v1052.0, v1044.0);
                                                                                                                        let v1068 = constructor_iconcat(ctx, I64, v1052.1, v1044.1);
                                                                                                                        let v1073 = constructor_ule(ctx, v2.0, v1067, v1068);
                                                                                                                        // Rule at src/opts/icmp.isle line 239.
                                                                                                                        returns.extend(Some(v1073));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::Ternary {
                                                            opcode: ref v1234,
                                                            args: ref v1235,
                                                        } => {
                                                            if let &Opcode::Select = v1234 {
                                                                if v2.0 == v1058.0 {
                                                                    let mut v1095 = C::inst_data_tupled_etor_returns::default();
                                                                    C::inst_data_tupled_etor(ctx, v86.1, &mut v1095);
                                                                    let mut v1095 = v1095.into_context_iter();
                                                                    while let Some(v1096) = v1095.next(ctx) {
                                                                        let v1097 = C::iconst_sextend_etor(ctx, v1096);
                                                                        if let Some(v1098) = v1097 {
                                                                            if v1098.1 == 0_i64 {
                                                                                if v2.0 == v1098.0 {
                                                                                    let v1236 = C::unpack_value_array_3(ctx, v1235);
                                                                                    let mut v1240 = C::inst_data_etor_returns::default();
                                                                                    C::inst_data_etor(ctx, v1236.0, &mut v1240);
                                                                                    let mut v1240 = v1240.into_context_iter();
                                                                                    while let Some(v1241) = v1240.next(ctx) {
                                                                                        if let &InstructionData::IntCompare {
                                                                                            opcode: ref v1244,
                                                                                            args: ref v1245,
                                                                                            cond: ref v1246,
                                                                                        } = &v1241.1 {
                                                                                            if let &Opcode::Icmp = v1244 {
                                                                                                match v1246 {
                                                                                                    &IntCC::SignedGreaterThan => {
                                                                                                        if v91.0 == v1241.0 {
                                                                                                            let v1044 = C::unpack_value_array_2(ctx, v1042);
                                                                                                            let v1247 = C::unpack_value_array_2(ctx, v1245);
                                                                                                            if v1044.0 == v1247.0 {
                                                                                                                if v1044.1 == v1247.1 {
                                                                                                                    let mut v1250 = C::inst_data_tupled_etor_returns::default();
                                                                                                                    C::inst_data_tupled_etor(ctx, v1236.1, &mut v1250);
                                                                                                                    let mut v1250 = v1250.into_context_iter();
                                                                                                                    while let Some(v1251) = v1250.next(ctx) {
                                                                                                                        let v1252 = C::iconst_sextend_etor(ctx, v1251);
                                                                                                                        if let Some(v1253) = v1252 {
                                                                                                                            if v1253.1 == 1_i64 {
                                                                                                                                if v2.0 == v1253.0 {
                                                                                                                                    let mut v1256 = C::inst_data_tupled_etor_returns::default();
                                                                                                                                    C::inst_data_tupled_etor(ctx, v1236.2, &mut v1256);
                                                                                                                                    let mut v1256 = v1256.into_context_iter();
                                                                                                                                    while let Some(v1257) = v1256.next(ctx) {
                                                                                                                                        let v1258 = C::iconst_sextend_etor(ctx, v1257);
                                                                                                                                        if let Some(v1259) = v1258 {
                                                                                                                                            if v1259.1 == -1_i64 {
                                                                                                                                                if v2.0 == v1259.0 {
                                                                                                                                                    let v1272 = constructor_spaceship_s(ctx, v91.0, v1044.0, v1044.1);
                                                                                                                                                    let v1273 = constructor_sextend_maybe(ctx, v2.0, v1272);
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 103.
                                                                                                                                                    returns.extend(Some(v1273));
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    &IntCC::SignedGreaterThanOrEqual => {
                                                                                                        if v91.0 == v1241.0 {
                                                                                                            let v1044 = C::unpack_value_array_2(ctx, v1042);
                                                                                                            let v1247 = C::unpack_value_array_2(ctx, v1245);
                                                                                                            if v1044.0 == v1247.0 {
                                                                                                                if v1044.1 == v1247.1 {
                                                                                                                    let mut v1250 = C::inst_data_tupled_etor_returns::default();
                                                                                                                    C::inst_data_tupled_etor(ctx, v1236.1, &mut v1250);
                                                                                                                    let mut v1250 = v1250.into_context_iter();
                                                                                                                    while let Some(v1251) = v1250.next(ctx) {
                                                                                                                        let v1252 = C::iconst_sextend_etor(ctx, v1251);
                                                                                                                        if let Some(v1253) = v1252 {
                                                                                                                            if v1253.1 == 1_i64 {
                                                                                                                                if v2.0 == v1253.0 {
                                                                                                                                    let mut v1256 = C::inst_data_tupled_etor_returns::default();
                                                                                                                                    C::inst_data_tupled_etor(ctx, v1236.2, &mut v1256);
                                                                                                                                    let mut v1256 = v1256.into_context_iter();
                                                                                                                                    while let Some(v1257) = v1256.next(ctx) {
                                                                                                                                        let v1258 = C::iconst_sextend_etor(ctx, v1257);
                                                                                                                                        if let Some(v1259) = v1258 {
                                                                                                                                            if v1259.1 == -1_i64 {
                                                                                                                                                if v2.0 == v1259.0 {
                                                                                                                                                    let v1272 = constructor_spaceship_s(ctx, v91.0, v1044.0, v1044.1);
                                                                                                                                                    let v1273 = constructor_sextend_maybe(ctx, v2.0, v1272);
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 110.
                                                                                                                                                    returns.extend(Some(v1273));
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    &IntCC::SignedLessThan => {
                                                                                                        if v91.0 == v1241.0 {
                                                                                                            let v1044 = C::unpack_value_array_2(ctx, v1042);
                                                                                                            let v1247 = C::unpack_value_array_2(ctx, v1245);
                                                                                                            if v1044.0 == v1247.0 {
                                                                                                                if v1044.1 == v1247.1 {
                                                                                                                    let mut v1250 = C::inst_data_tupled_etor_returns::default();
                                                                                                                    C::inst_data_tupled_etor(ctx, v1236.1, &mut v1250);
                                                                                                                    let mut v1250 = v1250.into_context_iter();
                                                                                                                    while let Some(v1251) = v1250.next(ctx) {
                                                                                                                        let v1252 = C::iconst_sextend_etor(ctx, v1251);
                                                                                                                        if let Some(v1253) = v1252 {
                                                                                                                            if v1253.1 == -1_i64 {
                                                                                                                                if v2.0 == v1253.0 {
                                                                                                                                    let mut v1256 = C::inst_data_tupled_etor_returns::default();
                                                                                                                                    C::inst_data_tupled_etor(ctx, v1236.2, &mut v1256);
                                                                                                                                    let mut v1256 = v1256.into_context_iter();
                                                                                                                                    while let Some(v1257) = v1256.next(ctx) {
                                                                                                                                        let v1258 = C::iconst_sextend_etor(ctx, v1257);
                                                                                                                                        if let Some(v1259) = v1258 {
                                                                                                                                            if v1259.1 == 1_i64 {
                                                                                                                                                if v2.0 == v1259.0 {
                                                                                                                                                    let v1272 = constructor_spaceship_s(ctx, v91.0, v1044.0, v1044.1);
                                                                                                                                                    let v1273 = constructor_sextend_maybe(ctx, v2.0, v1272);
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 89.
                                                                                                                                                    returns.extend(Some(v1273));
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    &IntCC::SignedLessThanOrEqual => {
                                                                                                        if v91.0 == v1241.0 {
                                                                                                            let v1044 = C::unpack_value_array_2(ctx, v1042);
                                                                                                            let v1247 = C::unpack_value_array_2(ctx, v1245);
                                                                                                            if v1044.0 == v1247.0 {
                                                                                                                if v1044.1 == v1247.1 {
                                                                                                                    let mut v1250 = C::inst_data_tupled_etor_returns::default();
                                                                                                                    C::inst_data_tupled_etor(ctx, v1236.1, &mut v1250);
                                                                                                                    let mut v1250 = v1250.into_context_iter();
                                                                                                                    while let Some(v1251) = v1250.next(ctx) {
                                                                                                                        let v1252 = C::iconst_sextend_etor(ctx, v1251);
                                                                                                                        if let Some(v1253) = v1252 {
                                                                                                                            if v1253.1 == -1_i64 {
                                                                                                                                if v2.0 == v1253.0 {
                                                                                                                                    let mut v1256 = C::inst_data_tupled_etor_returns::default();
                                                                                                                                    C::inst_data_tupled_etor(ctx, v1236.2, &mut v1256);
                                                                                                                                    let mut v1256 = v1256.into_context_iter();
                                                                                                                                    while let Some(v1257) = v1256.next(ctx) {
                                                                                                                                        let v1258 = C::iconst_sextend_etor(ctx, v1257);
                                                                                                                                        if let Some(v1259) = v1258 {
                                                                                                                                            if v1259.1 == 1_i64 {
                                                                                                                                                if v2.0 == v1259.0 {
                                                                                                                                                    let v1272 = constructor_spaceship_s(ctx, v91.0, v1044.0, v1044.1);
                                                                                                                                                    let v1273 = constructor_sextend_maybe(ctx, v2.0, v1272);
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 96.
                                                                                                                                                    returns.extend(Some(v1273));
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    &IntCC::UnsignedGreaterThan => {
                                                                                                        if v91.0 == v1241.0 {
                                                                                                            let v1044 = C::unpack_value_array_2(ctx, v1042);
                                                                                                            let v1247 = C::unpack_value_array_2(ctx, v1245);
                                                                                                            if v1044.0 == v1247.0 {
                                                                                                                if v1044.1 == v1247.1 {
                                                                                                                    let mut v1250 = C::inst_data_tupled_etor_returns::default();
                                                                                                                    C::inst_data_tupled_etor(ctx, v1236.1, &mut v1250);
                                                                                                                    let mut v1250 = v1250.into_context_iter();
                                                                                                                    while let Some(v1251) = v1250.next(ctx) {
                                                                                                                        let v1252 = C::iconst_sextend_etor(ctx, v1251);
                                                                                                                        if let Some(v1253) = v1252 {
                                                                                                                            if v1253.1 == 1_i64 {
                                                                                                                                if v2.0 == v1253.0 {
                                                                                                                                    let mut v1256 = C::inst_data_tupled_etor_returns::default();
                                                                                                                                    C::inst_data_tupled_etor(ctx, v1236.2, &mut v1256);
                                                                                                                                    let mut v1256 = v1256.into_context_iter();
                                                                                                                                    while let Some(v1257) = v1256.next(ctx) {
                                                                                                                                        let v1258 = C::iconst_sextend_etor(ctx, v1257);
                                                                                                                                        if let Some(v1259) = v1258 {
                                                                                                                                            if v1259.1 == -1_i64 {
                                                                                                                                                if v2.0 == v1259.0 {
                                                                                                                                                    let v1232 = constructor_spaceship_u(ctx, v91.0, v1044.0, v1044.1);
                                                                                                                                                    let v1233 = constructor_sextend_maybe(ctx, v2.0, v1232);
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 38.
                                                                                                                                                    returns.extend(Some(v1233));
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    &IntCC::UnsignedGreaterThanOrEqual => {
                                                                                                        if v91.0 == v1241.0 {
                                                                                                            let v1044 = C::unpack_value_array_2(ctx, v1042);
                                                                                                            let v1247 = C::unpack_value_array_2(ctx, v1245);
                                                                                                            if v1044.0 == v1247.0 {
                                                                                                                if v1044.1 == v1247.1 {
                                                                                                                    let mut v1250 = C::inst_data_tupled_etor_returns::default();
                                                                                                                    C::inst_data_tupled_etor(ctx, v1236.1, &mut v1250);
                                                                                                                    let mut v1250 = v1250.into_context_iter();
                                                                                                                    while let Some(v1251) = v1250.next(ctx) {
                                                                                                                        let v1252 = C::iconst_sextend_etor(ctx, v1251);
                                                                                                                        if let Some(v1253) = v1252 {
                                                                                                                            if v1253.1 == 1_i64 {
                                                                                                                                if v2.0 == v1253.0 {
                                                                                                                                    let mut v1256 = C::inst_data_tupled_etor_returns::default();
                                                                                                                                    C::inst_data_tupled_etor(ctx, v1236.2, &mut v1256);
                                                                                                                                    let mut v1256 = v1256.into_context_iter();
                                                                                                                                    while let Some(v1257) = v1256.next(ctx) {
                                                                                                                                        let v1258 = C::iconst_sextend_etor(ctx, v1257);
                                                                                                                                        if let Some(v1259) = v1258 {
                                                                                                                                            if v1259.1 == -1_i64 {
                                                                                                                                                if v2.0 == v1259.0 {
                                                                                                                                                    let v1232 = constructor_spaceship_u(ctx, v91.0, v1044.0, v1044.1);
                                                                                                                                                    let v1233 = constructor_sextend_maybe(ctx, v2.0, v1232);
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 45.
                                                                                                                                                    returns.extend(Some(v1233));
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    &IntCC::UnsignedLessThan => {
                                                                                                        if v91.0 == v1241.0 {
                                                                                                            let v1044 = C::unpack_value_array_2(ctx, v1042);
                                                                                                            let v1247 = C::unpack_value_array_2(ctx, v1245);
                                                                                                            if v1044.0 == v1247.0 {
                                                                                                                if v1044.1 == v1247.1 {
                                                                                                                    let mut v1250 = C::inst_data_tupled_etor_returns::default();
                                                                                                                    C::inst_data_tupled_etor(ctx, v1236.1, &mut v1250);
                                                                                                                    let mut v1250 = v1250.into_context_iter();
                                                                                                                    while let Some(v1251) = v1250.next(ctx) {
                                                                                                                        let v1252 = C::iconst_sextend_etor(ctx, v1251);
                                                                                                                        if let Some(v1253) = v1252 {
                                                                                                                            if v1253.1 == -1_i64 {
                                                                                                                                if v2.0 == v1253.0 {
                                                                                                                                    let mut v1256 = C::inst_data_tupled_etor_returns::default();
                                                                                                                                    C::inst_data_tupled_etor(ctx, v1236.2, &mut v1256);
                                                                                                                                    let mut v1256 = v1256.into_context_iter();
                                                                                                                                    while let Some(v1257) = v1256.next(ctx) {
                                                                                                                                        let v1258 = C::iconst_sextend_etor(ctx, v1257);
                                                                                                                                        if let Some(v1259) = v1258 {
                                                                                                                                            if v1259.1 == 1_i64 {
                                                                                                                                                if v2.0 == v1259.0 {
                                                                                                                                                    let v1232 = constructor_spaceship_u(ctx, v91.0, v1044.0, v1044.1);
                                                                                                                                                    let v1233 = constructor_sextend_maybe(ctx, v2.0, v1232);
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 24.
                                                                                                                                                    returns.extend(Some(v1233));
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    &IntCC::UnsignedLessThanOrEqual => {
                                                                                                        if v91.0 == v1241.0 {
                                                                                                            let v1044 = C::unpack_value_array_2(ctx, v1042);
                                                                                                            let v1247 = C::unpack_value_array_2(ctx, v1245);
                                                                                                            if v1044.0 == v1247.0 {
                                                                                                                if v1044.1 == v1247.1 {
                                                                                                                    let mut v1250 = C::inst_data_tupled_etor_returns::default();
                                                                                                                    C::inst_data_tupled_etor(ctx, v1236.1, &mut v1250);
                                                                                                                    let mut v1250 = v1250.into_context_iter();
                                                                                                                    while let Some(v1251) = v1250.next(ctx) {
                                                                                                                        let v1252 = C::iconst_sextend_etor(ctx, v1251);
                                                                                                                        if let Some(v1253) = v1252 {
                                                                                                                            if v1253.1 == -1_i64 {
                                                                                                                                if v2.0 == v1253.0 {
                                                                                                                                    let mut v1256 = C::inst_data_tupled_etor_returns::default();
                                                                                                                                    C::inst_data_tupled_etor(ctx, v1236.2, &mut v1256);
                                                                                                                                    let mut v1256 = v1256.into_context_iter();
                                                                                                                                    while let Some(v1257) = v1256.next(ctx) {
                                                                                                                                        let v1258 = C::iconst_sextend_etor(ctx, v1257);
                                                                                                                                        if let Some(v1259) = v1258 {
                                                                                                                                            if v1259.1 == 1_i64 {
                                                                                                                                                if v2.0 == v1259.0 {
                                                                                                                                                    let v1232 = constructor_spaceship_u(ctx, v91.0, v1044.0, v1044.1);
                                                                                                                                                    let v1233 = constructor_sextend_maybe(ctx, v2.0, v1232);
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 31.
                                                                                                                                                    returns.extend(Some(v1233));
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    _ => {}
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                            }
                                            &IntCC::SignedGreaterThan => {
                                                let mut v1057 = C::inst_data_etor_returns::default();
                                                C::inst_data_etor(ctx, v86.2, &mut v1057);
                                                let mut v1057 = v1057.into_context_iter();
                                                while let Some(v1058) = v1057.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v1131,
                                                        arg: v1132,
                                                    } = &v1058.1 {
                                                        match v1131 {
                                                            &Opcode::Ineg => {
                                                                if v91.0 == v1058.0 {
                                                                    let mut v1095 = C::inst_data_tupled_etor_returns::default();
                                                                    C::inst_data_tupled_etor(ctx, v86.1, &mut v1095);
                                                                    let mut v1095 = v1095.into_context_iter();
                                                                    while let Some(v1096) = v1095.next(ctx) {
                                                                        let v1097 = C::iconst_sextend_etor(ctx, v1096);
                                                                        if let Some(v1098) = v1097 {
                                                                            if v1098.1 == 1_i64 {
                                                                                if v2.0 == v1098.0 {
                                                                                    let mut v1262 = C::inst_data_etor_returns::default();
                                                                                    C::inst_data_etor(ctx, v1132, &mut v1262);
                                                                                    let mut v1262 = v1262.into_context_iter();
                                                                                    while let Some(v1263) = v1262.next(ctx) {
                                                                                        if let &InstructionData::IntCompare {
                                                                                            opcode: ref v1266,
                                                                                            args: ref v1267,
                                                                                            cond: ref v1268,
                                                                                        } = &v1263.1 {
                                                                                            if let &Opcode::Icmp = v1266 {
                                                                                                match v1268 {
                                                                                                    &IntCC::NotEqual => {
                                                                                                        if v91.0 == v1263.0 {
                                                                                                            let v1044 = C::unpack_value_array_2(ctx, v1042);
                                                                                                            let v1269 = C::unpack_value_array_2(ctx, v1267);
                                                                                                            if v1044.0 == v1269.0 {
                                                                                                                if v1044.1 == v1269.1 {
                                                                                                                    let v1272 = constructor_spaceship_s(ctx, v91.0, v1044.0, v1044.1);
                                                                                                                    let v1273 = constructor_sextend_maybe(ctx, v2.0, v1272);
                                                                                                                    // Rule at src/opts/spaceship.isle line 129.
                                                                                                                    returns.extend(Some(v1273));
                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    &IntCC::SignedLessThan => {
                                                                                                        if v91.0 == v1263.0 {
                                                                                                            let v1044 = C::unpack_value_array_2(ctx, v1042);
                                                                                                            let v1269 = C::unpack_value_array_2(ctx, v1267);
                                                                                                            if v1044.0 == v1269.0 {
                                                                                                                if v1044.1 == v1269.1 {
                                                                                                                    let v1272 = constructor_spaceship_s(ctx, v91.0, v1044.0, v1044.1);
                                                                                                                    let v1273 = constructor_sextend_maybe(ctx, v2.0, v1272);
                                                                                                                    // Rule at src/opts/spaceship.isle line 119.
                                                                                                                    returns.extend(Some(v1273));
                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    _ => {}
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Bmask => {
                                                                if v2.0 == v1058.0 {
                                                                    let mut v1095 = C::inst_data_tupled_etor_returns::default();
                                                                    C::inst_data_tupled_etor(ctx, v86.1, &mut v1095);
                                                                    let mut v1095 = v1095.into_context_iter();
                                                                    while let Some(v1096) = v1095.next(ctx) {
                                                                        let v1097 = C::iconst_sextend_etor(ctx, v1096);
                                                                        if let Some(v1098) = v1097 {
                                                                            if v1098.1 == 1_i64 {
                                                                                if v2.0 == v1098.0 {
                                                                                    let mut v1262 = C::inst_data_etor_returns::default();
                                                                                    C::inst_data_etor(ctx, v1132, &mut v1262);
                                                                                    let mut v1262 = v1262.into_context_iter();
                                                                                    while let Some(v1263) = v1262.next(ctx) {
                                                                                        if let &InstructionData::IntCompare {
                                                                                            opcode: ref v1266,
                                                                                            args: ref v1267,
                                                                                            cond: ref v1268,
                                                                                        } = &v1263.1 {
                                                                                            if let &Opcode::Icmp = v1266 {
                                                                                                match v1268 {
                                                                                                    &IntCC::NotEqual => {
                                                                                                        if v91.0 == v1263.0 {
                                                                                                            let v1044 = C::unpack_value_array_2(ctx, v1042);
                                                                                                            let v1269 = C::unpack_value_array_2(ctx, v1267);
                                                                                                            if v1044.0 == v1269.0 {
                                                                                                                if v1044.1 == v1269.1 {
                                                                                                                    let v1272 = constructor_spaceship_s(ctx, v91.0, v1044.0, v1044.1);
                                                                                                                    let v1273 = constructor_sextend_maybe(ctx, v2.0, v1272);
                                                                                                                    // Rule at src/opts/spaceship.isle line 133.
                                                                                                                    returns.extend(Some(v1273));
                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    &IntCC::SignedLessThan => {
                                                                                                        if v91.0 == v1263.0 {
                                                                                                            let v1044 = C::unpack_value_array_2(ctx, v1042);
                                                                                                            let v1269 = C::unpack_value_array_2(ctx, v1267);
                                                                                                            if v1044.0 == v1269.0 {
                                                                                                                if v1044.1 == v1269.1 {
                                                                                                                    let v1272 = constructor_spaceship_s(ctx, v91.0, v1044.0, v1044.1);
                                                                                                                    let v1273 = constructor_sextend_maybe(ctx, v2.0, v1272);
                                                                                                                    // Rule at src/opts/spaceship.isle line 123.
                                                                                                                    returns.extend(Some(v1273));
                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    _ => {}
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                    }
                                                }
                                                let v1044 = C::unpack_value_array_2(ctx, v1042);
                                                if v86.1 == v1044.0 {
                                                    if v86.2 == v1044.1 {
                                                        let v1108 = constructor_smax(ctx, v2.0, v1044.0, v1044.1);
                                                        // Rule at src/opts/selects.isle line 25.
                                                        returns.extend(Some(v1108));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v86.2 == v1044.0 {
                                                    if v86.1 == v1044.1 {
                                                        let v1110 = constructor_smin(ctx, v2.0, v1044.0, v1044.1);
                                                        // Rule at src/opts/selects.isle line 39.
                                                        returns.extend(Some(v1110));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::SignedGreaterThanOrEqual => {
                                                let v1044 = C::unpack_value_array_2(ctx, v1042);
                                                if v86.1 == v1044.0 {
                                                    if v86.2 == v1044.1 {
                                                        let v1108 = constructor_smax(ctx, v2.0, v1044.0, v1044.1);
                                                        // Rule at src/opts/selects.isle line 26.
                                                        returns.extend(Some(v1108));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v86.1 == v1044.1 {
                                                    if v86.2 == v1044.0 {
                                                        let v1110 = constructor_smin(ctx, v2.0, v1044.0, v1044.1);
                                                        // Rule at src/opts/selects.isle line 40.
                                                        returns.extend(Some(v1110));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::SignedLessThan => {
                                                let mut v1095 = C::inst_data_tupled_etor_returns::default();
                                                C::inst_data_tupled_etor(ctx, v86.1, &mut v1095);
                                                let mut v1095 = v1095.into_context_iter();
                                                while let Some(v1096) = v1095.next(ctx) {
                                                    let v1097 = C::iconst_sextend_etor(ctx, v1096);
                                                    if let Some(v1098) = v1097 {
                                                        if v1098.1 == -1_i64 {
                                                            if v2.0 == v1098.0 {
                                                                let mut v1218 = C::uextend_maybe_etor_returns::default();
                                                                C::uextend_maybe_etor(ctx, v86.2, &mut v1218);
                                                                let mut v1218 = v1218.into_context_iter();
                                                                while let Some(v1219) = v1218.next(ctx) {
                                                                    if v2.0 == v1219.0 {
                                                                        let mut v1222 = C::inst_data_etor_returns::default();
                                                                        C::inst_data_etor(ctx, v1219.1, &mut v1222);
                                                                        let mut v1222 = v1222.into_context_iter();
                                                                        while let Some(v1223) = v1222.next(ctx) {
                                                                            if let &InstructionData::IntCompare {
                                                                                opcode: ref v1226,
                                                                                args: ref v1227,
                                                                                cond: ref v1228,
                                                                            } = &v1223.1 {
                                                                                if let &Opcode::Icmp = v1226 {
                                                                                    match v1228 {
                                                                                        &IntCC::NotEqual => {
                                                                                            if v91.0 == v1223.0 {
                                                                                                let v1044 = C::unpack_value_array_2(ctx, v1042);
                                                                                                let v1229 = C::unpack_value_array_2(ctx, v1227);
                                                                                                if v1044.0 == v1229.0 {
                                                                                                    if v1044.1 == v1229.1 {
                                                                                                        let v1272 = constructor_spaceship_s(ctx, v91.0, v1044.0, v1044.1);
                                                                                                        let v1273 = constructor_sextend_maybe(ctx, v2.0, v1272);
                                                                                                        // Rule at src/opts/spaceship.isle line 77.
                                                                                                        returns.extend(Some(v1273));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                        &IntCC::SignedGreaterThan => {
                                                                                            if v91.0 == v1223.0 {
                                                                                                let v1044 = C::unpack_value_array_2(ctx, v1042);
                                                                                                let v1229 = C::unpack_value_array_2(ctx, v1227);
                                                                                                if v1044.0 == v1229.0 {
                                                                                                    if v1044.1 == v1229.1 {
                                                                                                        let v1272 = constructor_spaceship_s(ctx, v91.0, v1044.0, v1044.1);
                                                                                                        let v1273 = constructor_sextend_maybe(ctx, v2.0, v1272);
                                                                                                        // Rule at src/opts/spaceship.isle line 83.
                                                                                                        returns.extend(Some(v1273));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                        _ => {}
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                let v1044 = C::unpack_value_array_2(ctx, v1042);
                                                if v86.1 == v1044.0 {
                                                    if v86.2 == v1044.1 {
                                                        let v1110 = constructor_smin(ctx, v2.0, v1044.0, v1044.1);
                                                        // Rule at src/opts/selects.isle line 29.
                                                        returns.extend(Some(v1110));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v86.1 == v1044.1 {
                                                    if v86.2 == v1044.0 {
                                                        let v1108 = constructor_smax(ctx, v2.0, v1044.0, v1044.1);
                                                        // Rule at src/opts/selects.isle line 35.
                                                        returns.extend(Some(v1108));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::SignedLessThanOrEqual => {
                                                let v1044 = C::unpack_value_array_2(ctx, v1042);
                                                if v86.1 == v1044.0 {
                                                    if v86.2 == v1044.1 {
                                                        let v1110 = constructor_smin(ctx, v2.0, v1044.0, v1044.1);
                                                        // Rule at src/opts/selects.isle line 30.
                                                        returns.extend(Some(v1110));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v86.1 == v1044.1 {
                                                    if v86.2 == v1044.0 {
                                                        let v1108 = constructor_smax(ctx, v2.0, v1044.0, v1044.1);
                                                        // Rule at src/opts/selects.isle line 36.
                                                        returns.extend(Some(v1108));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::UnsignedGreaterThan => {
                                                let mut v1057 = C::inst_data_etor_returns::default();
                                                C::inst_data_etor(ctx, v86.2, &mut v1057);
                                                let mut v1057 = v1057.into_context_iter();
                                                while let Some(v1058) = v1057.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v1131,
                                                        arg: v1132,
                                                    } = &v1058.1 {
                                                        match v1131 {
                                                            &Opcode::Ineg => {
                                                                if v91.0 == v1058.0 {
                                                                    let mut v1095 = C::inst_data_tupled_etor_returns::default();
                                                                    C::inst_data_tupled_etor(ctx, v86.1, &mut v1095);
                                                                    let mut v1095 = v1095.into_context_iter();
                                                                    while let Some(v1096) = v1095.next(ctx) {
                                                                        let v1097 = C::iconst_sextend_etor(ctx, v1096);
                                                                        if let Some(v1098) = v1097 {
                                                                            if v1098.1 == 1_i64 {
                                                                                if v2.0 == v1098.0 {
                                                                                    let mut v1262 = C::inst_data_etor_returns::default();
                                                                                    C::inst_data_etor(ctx, v1132, &mut v1262);
                                                                                    let mut v1262 = v1262.into_context_iter();
                                                                                    while let Some(v1263) = v1262.next(ctx) {
                                                                                        if let &InstructionData::IntCompare {
                                                                                            opcode: ref v1266,
                                                                                            args: ref v1267,
                                                                                            cond: ref v1268,
                                                                                        } = &v1263.1 {
                                                                                            if let &Opcode::Icmp = v1266 {
                                                                                                match v1268 {
                                                                                                    &IntCC::NotEqual => {
                                                                                                        if v91.0 == v1263.0 {
                                                                                                            let v1044 = C::unpack_value_array_2(ctx, v1042);
                                                                                                            let v1269 = C::unpack_value_array_2(ctx, v1267);
                                                                                                            if v1044.0 == v1269.0 {
                                                                                                                if v1044.1 == v1269.1 {
                                                                                                                    let v1232 = constructor_spaceship_u(ctx, v91.0, v1044.0, v1044.1);
                                                                                                                    let v1233 = constructor_sextend_maybe(ctx, v2.0, v1232);
                                                                                                                    // Rule at src/opts/spaceship.isle line 64.
                                                                                                                    returns.extend(Some(v1233));
                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    &IntCC::UnsignedLessThan => {
                                                                                                        if v91.0 == v1263.0 {
                                                                                                            let v1044 = C::unpack_value_array_2(ctx, v1042);
                                                                                                            let v1269 = C::unpack_value_array_2(ctx, v1267);
                                                                                                            if v1044.0 == v1269.0 {
                                                                                                                if v1044.1 == v1269.1 {
                                                                                                                    let v1232 = constructor_spaceship_u(ctx, v91.0, v1044.0, v1044.1);
                                                                                                                    let v1233 = constructor_sextend_maybe(ctx, v2.0, v1232);
                                                                                                                    // Rule at src/opts/spaceship.isle line 54.
                                                                                                                    returns.extend(Some(v1233));
                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    _ => {}
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Bmask => {
                                                                if v2.0 == v1058.0 {
                                                                    let mut v1095 = C::inst_data_tupled_etor_returns::default();
                                                                    C::inst_data_tupled_etor(ctx, v86.1, &mut v1095);
                                                                    let mut v1095 = v1095.into_context_iter();
                                                                    while let Some(v1096) = v1095.next(ctx) {
                                                                        let v1097 = C::iconst_sextend_etor(ctx, v1096);
                                                                        if let Some(v1098) = v1097 {
                                                                            if v1098.1 == 1_i64 {
                                                                                if v2.0 == v1098.0 {
                                                                                    let mut v1262 = C::inst_data_etor_returns::default();
                                                                                    C::inst_data_etor(ctx, v1132, &mut v1262);
                                                                                    let mut v1262 = v1262.into_context_iter();
                                                                                    while let Some(v1263) = v1262.next(ctx) {
                                                                                        if let &InstructionData::IntCompare {
                                                                                            opcode: ref v1266,
                                                                                            args: ref v1267,
                                                                                            cond: ref v1268,
                                                                                        } = &v1263.1 {
                                                                                            if let &Opcode::Icmp = v1266 {
                                                                                                match v1268 {
                                                                                                    &IntCC::NotEqual => {
                                                                                                        if v91.0 == v1263.0 {
                                                                                                            let v1044 = C::unpack_value_array_2(ctx, v1042);
                                                                                                            let v1269 = C::unpack_value_array_2(ctx, v1267);
                                                                                                            if v1044.0 == v1269.0 {
                                                                                                                if v1044.1 == v1269.1 {
                                                                                                                    let v1232 = constructor_spaceship_u(ctx, v91.0, v1044.0, v1044.1);
                                                                                                                    let v1233 = constructor_sextend_maybe(ctx, v2.0, v1232);
                                                                                                                    // Rule at src/opts/spaceship.isle line 68.
                                                                                                                    returns.extend(Some(v1233));
                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    &IntCC::UnsignedLessThan => {
                                                                                                        if v91.0 == v1263.0 {
                                                                                                            let v1044 = C::unpack_value_array_2(ctx, v1042);
                                                                                                            let v1269 = C::unpack_value_array_2(ctx, v1267);
                                                                                                            if v1044.0 == v1269.0 {
                                                                                                                if v1044.1 == v1269.1 {
                                                                                                                    let v1232 = constructor_spaceship_u(ctx, v91.0, v1044.0, v1044.1);
                                                                                                                    let v1233 = constructor_sextend_maybe(ctx, v2.0, v1232);
                                                                                                                    // Rule at src/opts/spaceship.isle line 58.
                                                                                                                    returns.extend(Some(v1233));
                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    _ => {}
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                    }
                                                }
                                                let v1044 = C::unpack_value_array_2(ctx, v1042);
                                                if v86.1 == v1044.0 {
                                                    if v86.2 == v1044.1 {
                                                        let v1109 = constructor_umax(ctx, v2.0, v1044.0, v1044.1);
                                                        // Rule at src/opts/selects.isle line 27.
                                                        returns.extend(Some(v1109));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v86.2 == v1044.0 {
                                                    if v86.1 == v1044.1 {
                                                        let v1111 = constructor_umin(ctx, v2.0, v1044.0, v1044.1);
                                                        // Rule at src/opts/selects.isle line 41.
                                                        returns.extend(Some(v1111));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::UnsignedGreaterThanOrEqual => {
                                                let v1044 = C::unpack_value_array_2(ctx, v1042);
                                                if v86.1 == v1044.0 {
                                                    if v86.2 == v1044.1 {
                                                        let v1109 = constructor_umax(ctx, v2.0, v1044.0, v1044.1);
                                                        // Rule at src/opts/selects.isle line 28.
                                                        returns.extend(Some(v1109));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v86.1 == v1044.1 {
                                                    if v86.2 == v1044.0 {
                                                        let v1111 = constructor_umin(ctx, v2.0, v1044.0, v1044.1);
                                                        // Rule at src/opts/selects.isle line 42.
                                                        returns.extend(Some(v1111));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::UnsignedLessThan => {
                                                let mut v1095 = C::inst_data_tupled_etor_returns::default();
                                                C::inst_data_tupled_etor(ctx, v86.1, &mut v1095);
                                                let mut v1095 = v1095.into_context_iter();
                                                while let Some(v1096) = v1095.next(ctx) {
                                                    let v1097 = C::iconst_sextend_etor(ctx, v1096);
                                                    if let Some(v1098) = v1097 {
                                                        if v1098.1 == -1_i64 {
                                                            if v2.0 == v1098.0 {
                                                                let mut v1218 = C::uextend_maybe_etor_returns::default();
                                                                C::uextend_maybe_etor(ctx, v86.2, &mut v1218);
                                                                let mut v1218 = v1218.into_context_iter();
                                                                while let Some(v1219) = v1218.next(ctx) {
                                                                    if v2.0 == v1219.0 {
                                                                        let mut v1222 = C::inst_data_etor_returns::default();
                                                                        C::inst_data_etor(ctx, v1219.1, &mut v1222);
                                                                        let mut v1222 = v1222.into_context_iter();
                                                                        while let Some(v1223) = v1222.next(ctx) {
                                                                            if let &InstructionData::IntCompare {
                                                                                opcode: ref v1226,
                                                                                args: ref v1227,
                                                                                cond: ref v1228,
                                                                            } = &v1223.1 {
                                                                                if let &Opcode::Icmp = v1226 {
                                                                                    match v1228 {
                                                                                        &IntCC::NotEqual => {
                                                                                            if v91.0 == v1223.0 {
                                                                                                let v1044 = C::unpack_value_array_2(ctx, v1042);
                                                                                                let v1229 = C::unpack_value_array_2(ctx, v1227);
                                                                                                if v1044.0 == v1229.0 {
                                                                                                    if v1044.1 == v1229.1 {
                                                                                                        let v1232 = constructor_spaceship_u(ctx, v91.0, v1044.0, v1044.1);
                                                                                                        let v1233 = constructor_sextend_maybe(ctx, v2.0, v1232);
                                                                                                        // Rule at src/opts/spaceship.isle line 12.
                                                                                                        returns.extend(Some(v1233));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                        &IntCC::UnsignedGreaterThan => {
                                                                                            if v91.0 == v1223.0 {
                                                                                                let v1044 = C::unpack_value_array_2(ctx, v1042);
                                                                                                let v1229 = C::unpack_value_array_2(ctx, v1227);
                                                                                                if v1044.0 == v1229.0 {
                                                                                                    if v1044.1 == v1229.1 {
                                                                                                        let v1232 = constructor_spaceship_u(ctx, v91.0, v1044.0, v1044.1);
                                                                                                        let v1233 = constructor_sextend_maybe(ctx, v2.0, v1232);
                                                                                                        // Rule at src/opts/spaceship.isle line 18.
                                                                                                        returns.extend(Some(v1233));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                        _ => {}
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                let v1044 = C::unpack_value_array_2(ctx, v1042);
                                                if v86.1 == v1044.0 {
                                                    if v86.2 == v1044.1 {
                                                        let v1111 = constructor_umin(ctx, v2.0, v1044.0, v1044.1);
                                                        // Rule at src/opts/selects.isle line 31.
                                                        returns.extend(Some(v1111));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v86.1 == v1044.1 {
                                                    if v86.2 == v1044.0 {
                                                        let v1109 = constructor_umax(ctx, v2.0, v1044.0, v1044.1);
                                                        // Rule at src/opts/selects.isle line 37.
                                                        returns.extend(Some(v1109));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::UnsignedLessThanOrEqual => {
                                                let v1044 = C::unpack_value_array_2(ctx, v1042);
                                                if v86.1 == v1044.0 {
                                                    if v86.2 == v1044.1 {
                                                        let v1111 = constructor_umin(ctx, v2.0, v1044.0, v1044.1);
                                                        // Rule at src/opts/selects.isle line 32.
                                                        returns.extend(Some(v1111));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v86.1 == v1044.1 {
                                                    if v86.2 == v1044.0 {
                                                        let v1109 = constructor_umax(ctx, v2.0, v1044.0, v1044.1);
                                                        // Rule at src/opts/selects.isle line 38.
                                                        returns.extend(Some(v1109));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                        let mut v96 = C::inst_data_etor_returns::default();
                                        C::inst_data_etor(ctx, v86.1, &mut v96);
                                        let mut v96 = v96.into_context_iter();
                                        while let Some(v97) = v96.next(ctx) {
                                            if let &InstructionData::UnaryImm {
                                                opcode: ref v1084,
                                                imm: v1085,
                                            } = &v97.1 {
                                                if let &Opcode::Iconst = v1084 {
                                                    let v1086 = C::u64_from_imm64(ctx, v1085);
                                                    match v1086 {
                                                        0x0_u64 => {
                                                            let mut v1057 = C::inst_data_etor_returns::default();
                                                            C::inst_data_etor(ctx, v86.2, &mut v1057);
                                                            let mut v1057 = v1057.into_context_iter();
                                                            while let Some(v1058) = v1057.next(ctx) {
                                                                if let &InstructionData::UnaryImm {
                                                                    opcode: ref v1087,
                                                                    imm: v1088,
                                                                } = &v1058.1 {
                                                                    if let &Opcode::Iconst = v1087 {
                                                                        let v1089 = C::u64_from_imm64(ctx, v1088);
                                                                        let v1090 = C::u64_is_zero(ctx, v1089);
                                                                        if v1090 == false {
                                                                            let v1091 = &C::intcc_complement(ctx, v1043);
                                                                            let v1044 = C::unpack_value_array_2(ctx, v1042);
                                                                            let v1092 = constructor_icmp(ctx, v91.0, v1091, v1044.0, v1044.1);
                                                                            let v1093 = constructor_select(ctx, v2.0, v1092, v86.2, v86.1);
                                                                            // Rule at src/opts/selects.isle line 8.
                                                                            returns.extend(Some(v1093));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        0x1_u64 => {
                                                            let mut v1057 = C::inst_data_etor_returns::default();
                                                            C::inst_data_etor(ctx, v86.2, &mut v1057);
                                                            let mut v1057 = v1057.into_context_iter();
                                                            while let Some(v1058) = v1057.next(ctx) {
                                                                if let &InstructionData::UnaryImm {
                                                                    opcode: ref v1087,
                                                                    imm: v1088,
                                                                } = &v1058.1 {
                                                                    if let &Opcode::Iconst = v1087 {
                                                                        let v1089 = C::u64_from_imm64(ctx, v1088);
                                                                        if v1089 == 0x0_u64 {
                                                                            let v1094 = constructor_uextend_maybe(ctx, v2.0, v86.0);
                                                                            // Rule at src/opts/selects.isle line 14.
                                                                            returns.extend(Some(v1094));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                            }
                                        }
                                        let mut v1095 = C::inst_data_tupled_etor_returns::default();
                                        C::inst_data_tupled_etor(ctx, v86.1, &mut v1095);
                                        let mut v1095 = v1095.into_context_iter();
                                        while let Some(v1096) = v1095.next(ctx) {
                                            let v1097 = C::iconst_sextend_etor(ctx, v1096);
                                            if let Some(v1098) = v1097 {
                                                if v1098.1 == -1_i64 {
                                                    let mut v1101 = C::inst_data_tupled_etor_returns::default();
                                                    C::inst_data_tupled_etor(ctx, v86.2, &mut v1101);
                                                    let mut v1101 = v1101.into_context_iter();
                                                    while let Some(v1102) = v1101.next(ctx) {
                                                        let v1103 = C::iconst_sextend_etor(ctx, v1102);
                                                        if let Some(v1104) = v1103 {
                                                            if v1104.1 == 0_i64 {
                                                                let v1107 = constructor_bmask(ctx, v2.0, v86.0);
                                                                // Rule at src/opts/selects.isle line 19.
                                                                returns.extend(Some(v1107));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v94,
                                    arg: v95,
                                } => {
                                    if let &Opcode::Uextend = v94 {
                                        let mut v978 = C::inst_data_etor_returns::default();
                                        C::inst_data_etor(ctx, v95, &mut v978);
                                        let mut v978 = v978.into_context_iter();
                                        while let Some(v979) = v978.next(ctx) {
                                            if let &InstructionData::IntCompare {
                                                opcode: ref v982,
                                                args: ref v983,
                                                cond: ref v984,
                                            } = &v979.1 {
                                                if let &Opcode::Icmp = v982 {
                                                    let v988 = constructor_select(ctx, v2.0, v95, v86.1, v86.2);
                                                    // Rule at src/opts/icmp.isle line 46.
                                                    returns.extend(Some(v988));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    // Rule at src/opts/icmp.isle line 49.
                                                    returns.extend(Some(v988));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v641,
                                    imm: v642,
                                } => {
                                    if let &Opcode::Iconst = v641 {
                                        let v643 = C::u64_from_imm64(ctx, v642);
                                        if v643 == 0x0_u64 {
                                            let v646 = C::subsume(ctx, v86.2);
                                            // Rule at src/opts/cprop.isle line 171.
                                            returns.extend(Some(v646));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        let v644 = C::u64_is_zero(ctx, v643);
                                        if v644 == false {
                                            let v645 = C::subsume(ctx, v86.1);
                                            // Rule at src/opts/cprop.isle line 169.
                                            returns.extend(Some(v645));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                        let mut v96 = C::inst_data_etor_returns::default();
                        C::inst_data_etor(ctx, v86.1, &mut v96);
                        let mut v96 = v96.into_context_iter();
                        while let Some(v97) = v96.next(ctx) {
                            if let &InstructionData::Unary {
                                opcode: ref v100,
                                arg: v101,
                            } = &v97.1 {
                                match v100 {
                                    &Opcode::Uextend => {
                                        if v2.0 == v97.0 {
                                            let mut v1057 = C::inst_data_etor_returns::default();
                                            C::inst_data_etor(ctx, v86.2, &mut v1057);
                                            let mut v1057 = v1057.into_context_iter();
                                            while let Some(v1058) = v1057.next(ctx) {
                                                if let &InstructionData::Unary {
                                                    opcode: ref v1131,
                                                    arg: v1132,
                                                } = &v1058.1 {
                                                    if let &Opcode::Uextend = v1131 {
                                                        if v2.0 == v1058.0 {
                                                            let v1130 = C::value_type(ctx, v101);
                                                            let v1133 = C::value_type(ctx, v1132);
                                                            if v1130 == v1133 {
                                                                let v1134 = constructor_select(ctx, v1130, v86.0, v101, v1132);
                                                                let v1135 = constructor_uextend(ctx, v2.0, v1134);
                                                                // Rule at src/opts/selects.isle line 80.
                                                                returns.extend(Some(v1135));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    &Opcode::Sextend => {
                                        if v2.0 == v97.0 {
                                            let mut v1057 = C::inst_data_etor_returns::default();
                                            C::inst_data_etor(ctx, v86.2, &mut v1057);
                                            let mut v1057 = v1057.into_context_iter();
                                            while let Some(v1058) = v1057.next(ctx) {
                                                if let &InstructionData::Unary {
                                                    opcode: ref v1131,
                                                    arg: v1132,
                                                } = &v1058.1 {
                                                    if let &Opcode::Sextend = v1131 {
                                                        if v2.0 == v1058.0 {
                                                            let v1130 = C::value_type(ctx, v101);
                                                            let v1133 = C::value_type(ctx, v1132);
                                                            if v1130 == v1133 {
                                                                let v1134 = constructor_select(ctx, v1130, v86.0, v101, v1132);
                                                                let v1136 = constructor_sextend(ctx, v2.0, v1134);
                                                                // Rule at src/opts/selects.isle line 84.
                                                                returns.extend(Some(v1136));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                        }
                        if v86.1 == v86.2 {
                            // Rule at src/opts/selects.isle line 3.
                            returns.extend(Some(v86.1));
                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                        }
                        let mut v250 = ContextIterWrapper::<ConstructorVec<_>, _>::default();
                        constructor_truthy(ctx, v86.0, &mut v250);
                        let mut v250 = v250.into_context_iter();
                        while let Some(v251) = v250.next(ctx) {
                            let v252 = constructor_select(ctx, v2.0, v251, v86.1, v86.2);
                            // Rule at src/opts/bitops.isle line 117.
                            returns.extend(Some(v252));
                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                        }
                    }
                    &Opcode::SelectSpectreGuard => {
                        let v86 = C::unpack_value_array_3(ctx, v85);
                        let mut v90 = C::inst_data_etor_returns::default();
                        C::inst_data_etor(ctx, v86.0, &mut v90);
                        let mut v90 = v90.into_context_iter();
                        while let Some(v91) = v90.next(ctx) {
                            if let &InstructionData::UnaryImm {
                                opcode: ref v641,
                                imm: v642,
                            } = &v91.1 {
                                if let &Opcode::Iconst = v641 {
                                    let v643 = C::u64_from_imm64(ctx, v642);
                                    if v643 == 0x0_u64 {
                                        let v646 = C::subsume(ctx, v86.2);
                                        // Rule at src/opts/spectre.isle line 12.
                                        returns.extend(Some(v646));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                    let v644 = C::u64_is_zero(ctx, v643);
                                    if v644 == false {
                                        let v645 = C::subsume(ctx, v86.1);
                                        // Rule at src/opts/spectre.isle line 10.
                                        returns.extend(Some(v645));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                            }
                        }
                        if v86.1 == v86.2 {
                            let v645 = C::subsume(ctx, v86.1);
                            // Rule at src/opts/spectre.isle line 8.
                            returns.extend(Some(v645));
                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                        }
                    }
                    &Opcode::Bitselect => {
                        let v1112 = C::multi_lane(ctx, v2.0);
                        if let Some(v1113) = v1112 {
                            let v86 = C::unpack_value_array_3(ctx, v85);
                            let mut v90 = C::inst_data_etor_returns::default();
                            C::inst_data_etor(ctx, v86.0, &mut v90);
                            let mut v90 = v90.into_context_iter();
                            while let Some(v91) = v90.next(ctx) {
                                if let &InstructionData::IntCompare {
                                    opcode: ref v1041,
                                    args: ref v1042,
                                    cond: ref v1043,
                                } = &v91.1 {
                                    if let &Opcode::Icmp = v1041 {
                                        match v1043 {
                                            &IntCC::SignedGreaterThan => {
                                                let v1044 = C::unpack_value_array_2(ctx, v1042);
                                                if v86.1 == v1044.0 {
                                                    if v86.2 == v1044.1 {
                                                        let v1108 = constructor_smax(ctx, v2.0, v1044.0, v1044.1);
                                                        // Rule at src/opts/selects.isle line 45.
                                                        returns.extend(Some(v1108));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v86.1 == v1044.1 {
                                                    if v86.2 == v1044.0 {
                                                        let v1110 = constructor_smin(ctx, v2.0, v1044.0, v1044.1);
                                                        // Rule at src/opts/selects.isle line 59.
                                                        returns.extend(Some(v1110));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::SignedGreaterThanOrEqual => {
                                                let v1044 = C::unpack_value_array_2(ctx, v1042);
                                                if v86.1 == v1044.0 {
                                                    if v86.2 == v1044.1 {
                                                        let v1108 = constructor_smax(ctx, v2.0, v1044.0, v1044.1);
                                                        // Rule at src/opts/selects.isle line 46.
                                                        returns.extend(Some(v1108));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v86.1 == v1044.1 {
                                                    if v86.2 == v1044.0 {
                                                        let v1110 = constructor_smin(ctx, v2.0, v1044.0, v1044.1);
                                                        // Rule at src/opts/selects.isle line 60.
                                                        returns.extend(Some(v1110));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::SignedLessThan => {
                                                let v1044 = C::unpack_value_array_2(ctx, v1042);
                                                if v86.1 == v1044.0 {
                                                    if v86.2 == v1044.1 {
                                                        let v1110 = constructor_smin(ctx, v2.0, v1044.0, v1044.1);
                                                        // Rule at src/opts/selects.isle line 49.
                                                        returns.extend(Some(v1110));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v86.1 == v1044.1 {
                                                    if v86.2 == v1044.0 {
                                                        let v1108 = constructor_smax(ctx, v2.0, v1044.0, v1044.1);
                                                        // Rule at src/opts/selects.isle line 55.
                                                        returns.extend(Some(v1108));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::SignedLessThanOrEqual => {
                                                let v1044 = C::unpack_value_array_2(ctx, v1042);
                                                if v86.1 == v1044.0 {
                                                    if v86.2 == v1044.1 {
                                                        let v1110 = constructor_smin(ctx, v2.0, v1044.0, v1044.1);
                                                        // Rule at src/opts/selects.isle line 50.
                                                        returns.extend(Some(v1110));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v86.1 == v1044.1 {
                                                    if v86.2 == v1044.0 {
                                                        let v1108 = constructor_smax(ctx, v2.0, v1044.0, v1044.1);
                                                        // Rule at src/opts/selects.isle line 56.
                                                        returns.extend(Some(v1108));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::UnsignedGreaterThan => {
                                                let v1044 = C::unpack_value_array_2(ctx, v1042);
                                                if v86.1 == v1044.0 {
                                                    if v86.2 == v1044.1 {
                                                        let v1109 = constructor_umax(ctx, v2.0, v1044.0, v1044.1);
                                                        // Rule at src/opts/selects.isle line 47.
                                                        returns.extend(Some(v1109));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v86.1 == v1044.1 {
                                                    if v86.2 == v1044.0 {
                                                        let v1111 = constructor_umin(ctx, v2.0, v1044.0, v1044.1);
                                                        // Rule at src/opts/selects.isle line 61.
                                                        returns.extend(Some(v1111));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::UnsignedGreaterThanOrEqual => {
                                                let v1044 = C::unpack_value_array_2(ctx, v1042);
                                                if v86.1 == v1044.0 {
                                                    if v86.2 == v1044.1 {
                                                        let v1109 = constructor_umax(ctx, v2.0, v1044.0, v1044.1);
                                                        // Rule at src/opts/selects.isle line 48.
                                                        returns.extend(Some(v1109));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v86.1 == v1044.1 {
                                                    if v86.2 == v1044.0 {
                                                        let v1111 = constructor_umin(ctx, v2.0, v1044.0, v1044.1);
                                                        // Rule at src/opts/selects.isle line 62.
                                                        returns.extend(Some(v1111));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::UnsignedLessThan => {
                                                let v1044 = C::unpack_value_array_2(ctx, v1042);
                                                if v86.1 == v1044.0 {
                                                    if v86.2 == v1044.1 {
                                                        let v1111 = constructor_umin(ctx, v2.0, v1044.0, v1044.1);
                                                        // Rule at src/opts/selects.isle line 51.
                                                        returns.extend(Some(v1111));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v86.1 == v1044.1 {
                                                    if v86.2 == v1044.0 {
                                                        let v1109 = constructor_umax(ctx, v2.0, v1044.0, v1044.1);
                                                        // Rule at src/opts/selects.isle line 57.
                                                        returns.extend(Some(v1109));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::UnsignedLessThanOrEqual => {
                                                let v1044 = C::unpack_value_array_2(ctx, v1042);
                                                if v86.1 == v1044.0 {
                                                    if v86.2 == v1044.1 {
                                                        let v1111 = constructor_umin(ctx, v2.0, v1044.0, v1044.1);
                                                        // Rule at src/opts/selects.isle line 52.
                                                        returns.extend(Some(v1111));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v86.1 == v1044.1 {
                                                    if v86.2 == v1044.0 {
                                                        let v1109 = constructor_umax(ctx, v2.0, v1044.0, v1044.1);
                                                        // Rule at src/opts/selects.isle line 58.
                                                        returns.extend(Some(v1109));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                }
                            }
                        }
                        let v86 = C::unpack_value_array_3(ctx, v85);
                        if v86.1 == v86.2 {
                            // Rule at src/opts/selects.isle line 4.
                            returns.extend(Some(v86.1));
                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                        }
                    }
                    &Opcode::Fma => {
                        let v86 = C::unpack_value_array_3(ctx, v85);
                        let mut v90 = C::inst_data_etor_returns::default();
                        C::inst_data_etor(ctx, v86.0, &mut v90);
                        let mut v90 = v90.into_context_iter();
                        while let Some(v91) = v90.next(ctx) {
                            if let &InstructionData::Unary {
                                opcode: ref v94,
                                arg: v95,
                            } = &v91.1 {
                                if let &Opcode::Fneg = v94 {
                                    if v2.0 == v91.0 {
                                        let mut v96 = C::inst_data_etor_returns::default();
                                        C::inst_data_etor(ctx, v86.1, &mut v96);
                                        let mut v96 = v96.into_context_iter();
                                        while let Some(v97) = v96.next(ctx) {
                                            if let &InstructionData::Unary {
                                                opcode: ref v100,
                                                arg: v101,
                                            } = &v97.1 {
                                                if let &Opcode::Fneg = v100 {
                                                    if v2.0 == v97.0 {
                                                        let v102 = constructor_fma(ctx, v2.0, v95, v101, v86.2);
                                                        // Rule at src/opts/arithmetic.isle line 108.
                                                        returns.extend(Some(v102));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    _ => {}
                }
            }
            &InstructionData::Unary {
                opcode: ref v32,
                arg: v33,
            } => {
                match v32 {
                    &Opcode::Splat => {
                        let mut v34 = C::inst_data_etor_returns::default();
                        C::inst_data_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 v669,
                                    imm: v670,
                                } => {
                                    if let &Opcode::F32const = v669 {
                                        let v671 = C::u32_from_ieee32(ctx, v670);
                                        let v672 = C::u32_as_u64(ctx, v671);
                                        let v673 = constructor_splat32(ctx, v672);
                                        let v674 = constructor_vconst(ctx, v2.0, v673);
                                        // Rule at src/opts/cprop.isle line 194.
                                        returns.extend(Some(v674));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                &InstructionData::UnaryIeee64 {
                                    opcode: ref v675,
                                    imm: v676,
                                } => {
                                    if let &Opcode::F64const = v675 {
                                        let v677 = C::u64_from_ieee64(ctx, v676);
                                        let v678 = C::splat64(ctx, v677);
                                        let v679 = constructor_vconst(ctx, v2.0, v678);
                                        // Rule at src/opts/cprop.isle line 196.
                                        returns.extend(Some(v679));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v562,
                                    imm: v563,
                                } => {
                                    if let &Opcode::Iconst = v562 {
                                        match v35.0 {
                                            I8 => {
                                                let v654 = C::u64_uextend_imm64(ctx, I8, v563);
                                                let v655 = constructor_splat8(ctx, v654);
                                                let v656 = constructor_vconst(ctx, v2.0, v655);
                                                // Rule at src/opts/cprop.isle line 186.
                                                returns.extend(Some(v656));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            I16 => {
                                                let v658 = C::u64_uextend_imm64(ctx, I16, v563);
                                                let v659 = constructor_splat16(ctx, v658);
                                                let v660 = constructor_vconst(ctx, v2.0, v659);
                                                // Rule at src/opts/cprop.isle line 188.
                                                returns.extend(Some(v660));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            I32 => {
                                                let v662 = C::u64_uextend_imm64(ctx, I32, v563);
                                                let v663 = constructor_splat32(ctx, v662);
                                                let v664 = constructor_vconst(ctx, v2.0, v663);
                                                // Rule at src/opts/cprop.isle line 190.
                                                returns.extend(Some(v664));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            I64 => {
                                                let v666 = C::u64_uextend_imm64(ctx, I64, v563);
                                                let v667 = C::splat64(ctx, v666);
                                                let v668 = constructor_vconst(ctx, v2.0, v667);
                                                // Rule at src/opts/cprop.isle line 192.
                                                returns.extend(Some(v668));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            _ => {}
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                    }
                    &Opcode::Ineg => {
                        let mut v34 = C::inst_data_etor_returns::default();
                        C::inst_data_etor(ctx, v33, &mut v34);
                        let mut v34 = v34.into_context_iter();
                        while let Some(v35) = v34.next(ctx) {
                            match &v35.1 {
                                &InstructionData::Binary {
                                    opcode: ref v38,
                                    args: ref v39,
                                } => {
                                    match v38 {
                                        &Opcode::Isub => {
                                            if v2.0 == v35.0 {
                                                let v40 = C::unpack_value_array_2(ctx, v39);
                                                let v43 = constructor_isub(ctx, v2.0, v40.1, v40.0);
                                                // Rule at src/opts/arithmetic.isle line 27.
                                                returns.extend(Some(v43));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        &Opcode::Ushr => {
                                            if v2.0 == v35.0 {
                                                let v40 = C::unpack_value_array_2(ctx, v39);
                                                let mut v1162 = C::inst_data_etor_returns::default();
                                                C::inst_data_etor(ctx, v40.1, &mut v1162);
                                                let mut v1162 = v1162.into_context_iter();
                                                while let Some(v1163) = v1162.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v1166,
                                                        imm: v1167,
                                                    } = &v1163.1 {
                                                        if let &Opcode::Iconst = v1166 {
                                                            let v1168 = C::u64_from_imm64(ctx, v1167);
                                                            let v235 = constructor_ty_shift_mask(ctx, v2.0);
                                                            let v1169 = C::u64_eq(ctx, v1168, v235);
                                                            if v1169 == true {
                                                                if v2.0 == v1163.0 {
                                                                    let v1170 = constructor_sshr(ctx, v2.0, v40.0, v40.1);
                                                                    // Rule at src/opts/shifts.isle line 98.
                                                                    returns.extend(Some(v1170));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v45,
                                    arg: v46,
                                } => {
                                    match v45 {
                                        &Opcode::Splat => {
                                            if v2.0 == v35.0 {
                                                let v1186 = C::lane_type(ctx, v2.0);
                                                let v1333 = constructor_ineg(ctx, v1186, v46);
                                                let v1334 = constructor_splat(ctx, v2.0, v1333);
                                                // Rule at src/opts/vector.isle line 45.
                                                returns.extend(Some(v1334));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        &Opcode::Ineg => {
                                            if v2.0 == v35.0 {
                                                let v47 = C::subsume(ctx, v46);
                                                // Rule at src/opts/arithmetic.isle line 34.
                                                returns.extend(Some(v47));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                _ => {}
                            }
                        }
                    }
                    &Opcode::Iabs => {
                        let mut v34 = C::inst_data_etor_returns::default();
                        C::inst_data_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 v1186 = C::lane_type(ctx, v2.0);
                                            let v1335 = constructor_iabs(ctx, v1186, v46);
                                            let v1336 = constructor_splat(ctx, v2.0, v1335);
                                            // Rule at src/opts/vector.isle line 48.
                                            returns.extend(Some(v1336));
                                            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_etor_returns::default();
                        C::inst_data_etor(ctx, v33, &mut v34);
                        let mut v34 = v34.into_context_iter();
                        while let Some(v35) = v34.next(ctx) {
                            match &v35.1 {
                                &InstructionData::Binary {
                                    opcode: ref v38,
                                    args: ref v39,
                                } => {
                                    match v38 {
                                        &Opcode::Iadd => {
                                            if v2.0 == v35.0 {
                                                let v40 = C::unpack_value_array_2(ctx, v39);
                                                let mut v66 = C::inst_data_tupled_etor_returns::default();
                                                C::inst_data_tupled_etor(ctx, v40.1, &mut v66);
                                                let mut v66 = v66.into_context_iter();
                                                while let Some(v67) = v66.next(ctx) {
                                                    let v68 = C::iconst_sextend_etor(ctx, v67);
                                                    if let Some(v69) = v68 {
                                                        if v69.1 == -1_i64 {
                                                            if v2.0 == v69.0 {
                                                                let v72 = constructor_ineg(ctx, v2.0, v40.0);
                                                                // Rule at src/opts/arithmetic.isle line 74.
                                                                returns.extend(Some(v72));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Isub => {
                                            if v2.0 == v35.0 {
                                                let v40 = C::unpack_value_array_2(ctx, v39);
                                                let mut v66 = C::inst_data_tupled_etor_returns::default();
                                                C::inst_data_tupled_etor(ctx, v40.1, &mut v66);
                                                let mut v66 = v66.into_context_iter();
                                                while let Some(v67) = v66.next(ctx) {
                                                    let v68 = C::iconst_sextend_etor(ctx, v67);
                                                    if let Some(v69) = v68 {
                                                        if v69.1 == 1_i64 {
                                                            if v2.0 == v69.0 {
                                                                let v72 = constructor_ineg(ctx, v2.0, v40.0);
                                                                // Rule at src/opts/arithmetic.isle line 72.
                                                                returns.extend(Some(v72));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Band => {
                                            let v40 = C::unpack_value_array_2(ctx, v39);
                                            let v220 = constructor_bnot(ctx, v2.0, v40.0);
                                            let v221 = constructor_bnot(ctx, v2.0, v40.1);
                                            let v223 = constructor_bor(ctx, v2.0, v220, v221);
                                            // Rule at src/opts/bitops.isle line 45.
                                            returns.extend(Some(v223));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Bor => {
                                            if v2.0 == v35.0 {
                                                let v40 = C::unpack_value_array_2(ctx, v39);
                                                let v220 = constructor_bnot(ctx, v2.0, v40.0);
                                                let v221 = constructor_bnot(ctx, v2.0, v40.1);
                                                let v222 = constructor_band(ctx, v2.0, v220, v221);
                                                // Rule at src/opts/bitops.isle line 42.
                                                returns.extend(Some(v222));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v45,
                                    arg: v46,
                                } => {
                                    match v45 {
                                        &Opcode::Splat => {
                                            let v1313 = C::ty_vector_not_float(ctx, v2.0);
                                            if let Some(v1314) = v1313 {
                                                if v2.0 == v35.0 {
                                                    let v1186 = C::lane_type(ctx, v2.0);
                                                    let v1321 = constructor_bnot(ctx, v1186, v46);
                                                    let v1322 = constructor_splat(ctx, v2.0, v1321);
                                                    // Rule at src/opts/vector.isle line 26.
                                                    returns.extend(Some(v1322));
                                                    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 38.
                                                returns.extend(Some(v47));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v562,
                                    imm: v563,
                                } => {
                                    if let &Opcode::Iconst = v562 {
                                        let v526 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v527) = v526 {
                                            if v35.0 == v527 {
                                                let v564 = C::u64_from_imm64(ctx, v563);
                                                let v565 = C::u64_not(ctx, v564);
                                                let v566 = C::imm64_masked(ctx, v527, v565);
                                                let v567 = constructor_iconst(ctx, v527, v566);
                                                let v568 = C::subsume(ctx, v567);
                                                // Rule at src/opts/cprop.isle line 52.
                                                returns.extend(Some(v568));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                        let v1077 = C::remat(ctx, arg0);
                        // Rule at src/opts/remat.isle line 23.
                        returns.extend(Some(v1077));
                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                    }
                    &Opcode::Bitrev => {
                        let mut v34 = C::inst_data_etor_returns::default();
                        C::inst_data_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 136.
                                        returns.extend(Some(v47));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                            }
                        }
                    }
                    &Opcode::Bswap => {
                        let mut v34 = C::inst_data_etor_returns::default();
                        C::inst_data_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 133.
                                            returns.extend(Some(v47));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v562,
                                    imm: v563,
                                } => {
                                    if let &Opcode::Iconst = v562 {
                                        match v2.0 {
                                            I16 => {
                                                let v564 = C::u64_from_imm64(ctx, v563);
                                                let v713 = C::u64_bswap16(ctx, v564);
                                                let v714 = C::imm64(ctx, v713);
                                                let v715 = constructor_iconst(ctx, I16, v714);
                                                let v716 = C::subsume(ctx, v715);
                                                // Rule at src/opts/cprop.isle line 266.
                                                returns.extend(Some(v716));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            I32 => {
                                                let v564 = C::u64_from_imm64(ctx, v563);
                                                let v717 = C::u64_bswap32(ctx, v564);
                                                let v718 = C::imm64(ctx, v717);
                                                let v719 = constructor_iconst(ctx, I32, v718);
                                                let v720 = C::subsume(ctx, v719);
                                                // Rule at src/opts/cprop.isle line 268.
                                                returns.extend(Some(v720));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            I64 => {
                                                let v564 = C::u64_from_imm64(ctx, v563);
                                                let v721 = C::u64_bswap64(ctx, v564);
                                                let v722 = C::imm64(ctx, v721);
                                                let v723 = constructor_iconst(ctx, I64, v722);
                                                let v724 = C::subsume(ctx, v723);
                                                // Rule at src/opts/cprop.isle line 270.
                                                returns.extend(Some(v724));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            _ => {}
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                    }
                    &Opcode::Popcnt => {
                        let mut v34 = C::inst_data_etor_returns::default();
                        C::inst_data_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 v1186 = C::lane_type(ctx, v2.0);
                                        let v1337 = constructor_popcnt(ctx, v1186, v46);
                                        let v1338 = constructor_splat(ctx, v2.0, v1337);
                                        // Rule at src/opts/vector.isle line 51.
                                        returns.extend(Some(v1338));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                            }
                        }
                    }
                    &Opcode::Sqrt => {
                        match v2.0 {
                            F32 => {
                                let mut v34 = C::inst_data_etor_returns::default();
                                C::inst_data_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 v669,
                                            imm: v670,
                                        } = &v35.1 {
                                            if let &Opcode::F32const = v669 {
                                                let v765 = C::f32_sqrt(ctx, v670);
                                                if let Some(v766) = v765 {
                                                    let v767 = constructor_f32const(ctx, F32, v766);
                                                    let v768 = C::subsume(ctx, v767);
                                                    // Rule at src/opts/cprop.isle line 317.
                                                    returns.extend(Some(v768));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            F64 => {
                                let mut v34 = C::inst_data_etor_returns::default();
                                C::inst_data_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 v675,
                                            imm: v676,
                                        } = &v35.1 {
                                            if let &Opcode::F64const = v675 {
                                                let v769 = C::f64_sqrt(ctx, v676);
                                                if let Some(v770) = v769 {
                                                    let v771 = constructor_f64const(ctx, F64, v770);
                                                    let v772 = C::subsume(ctx, v771);
                                                    // Rule at src/opts/cprop.isle line 320.
                                                    returns.extend(Some(v772));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            _ => {}
                        }
                    }
                    &Opcode::Fneg => {
                        let mut v34 = C::inst_data_etor_returns::default();
                        C::inst_data_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 104.
                                            returns.extend(Some(v47));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                                &InstructionData::UnaryConst {
                                    opcode: ref v864,
                                    constant_handle: v865,
                                } => {
                                    if let &Opcode::F128const = v864 {
                                        if v2.0 == F128 {
                                            if v35.0 == F128 {
                                                let v866 = C::ieee128_constant_extractor(ctx, v865);
                                                if let Some(v867) = v866 {
                                                    let v868 = C::f128_neg(ctx, v867);
                                                    let v869 = C::ieee128_constant(ctx, v868);
                                                    let v870 = constructor_f128const(ctx, F128, v869);
                                                    let v871 = C::subsume(ctx, v870);
                                                    // Rule at src/opts/cprop.isle line 384.
                                                    returns.extend(Some(v871));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryIeee16 {
                                    opcode: ref v853,
                                    imm: v854,
                                } => {
                                    if let &Opcode::F16const = v853 {
                                        if v2.0 == F16 {
                                            if v35.0 == F16 {
                                                let v855 = C::f16_neg(ctx, v854);
                                                let v856 = constructor_f16const(ctx, F16, v855);
                                                let v857 = C::subsume(ctx, v856);
                                                // Rule at src/opts/cprop.isle line 378.
                                                returns.extend(Some(v857));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryIeee32 {
                                    opcode: ref v669,
                                    imm: v670,
                                } => {
                                    if let &Opcode::F32const = v669 {
                                        if v2.0 == F32 {
                                            if v35.0 == F32 {
                                                let v858 = C::f32_neg(ctx, v670);
                                                let v859 = constructor_f32const(ctx, F32, v858);
                                                let v860 = C::subsume(ctx, v859);
                                                // Rule at src/opts/cprop.isle line 380.
                                                returns.extend(Some(v860));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryIeee64 {
                                    opcode: ref v675,
                                    imm: v676,
                                } => {
                                    if let &Opcode::F64const = v675 {
                                        if v2.0 == F64 {
                                            if v35.0 == F64 {
                                                let v861 = C::f64_neg(ctx, v676);
                                                let v862 = constructor_f64const(ctx, F64, v861);
                                                let v863 = C::subsume(ctx, v862);
                                                // Rule at src/opts/cprop.isle line 382.
                                                returns.extend(Some(v863));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                    }
                    &Opcode::Fabs => {
                        match v2.0 {
                            F16 => {
                                let mut v34 = C::inst_data_etor_returns::default();
                                C::inst_data_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 v853,
                                            imm: v854,
                                        } = &v35.1 {
                                            if let &Opcode::F16const = v853 {
                                                let v872 = C::f16_abs(ctx, v854);
                                                let v873 = constructor_f16const(ctx, F16, v872);
                                                let v874 = C::subsume(ctx, v873);
                                                // Rule at src/opts/cprop.isle line 387.
                                                returns.extend(Some(v874));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                }
                            }
                            F32 => {
                                let mut v34 = C::inst_data_etor_returns::default();
                                C::inst_data_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 v669,
                                            imm: v670,
                                        } = &v35.1 {
                                            if let &Opcode::F32const = v669 {
                                                let v875 = C::f32_abs(ctx, v670);
                                                let v876 = constructor_f32const(ctx, F32, v875);
                                                let v877 = C::subsume(ctx, v876);
                                                // Rule at src/opts/cprop.isle line 389.
                                                returns.extend(Some(v877));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                }
                            }
                            F64 => {
                                let mut v34 = C::inst_data_etor_returns::default();
                                C::inst_data_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 v675,
                                            imm: v676,
                                        } = &v35.1 {
                                            if let &Opcode::F64const = v675 {
                                                let v878 = C::f64_abs(ctx, v676);
                                                let v879 = constructor_f64const(ctx, F64, v878);
                                                let v880 = C::subsume(ctx, v879);
                                                // Rule at src/opts/cprop.isle line 391.
                                                returns.extend(Some(v880));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                }
                            }
                            F128 => {
                                let mut v34 = C::inst_data_etor_returns::default();
                                C::inst_data_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 v864,
                                            constant_handle: v865,
                                        } = &v35.1 {
                                            if let &Opcode::F128const = v864 {
                                                let v866 = C::ieee128_constant_extractor(ctx, v865);
                                                if let Some(v867) = v866 {
                                                    let v881 = C::f128_abs(ctx, v867);
                                                    let v882 = C::ieee128_constant(ctx, v881);
                                                    let v883 = constructor_f128const(ctx, F128, v882);
                                                    let v884 = C::subsume(ctx, v883);
                                                    // Rule at src/opts/cprop.isle line 393.
                                                    returns.extend(Some(v884));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            _ => {}
                        }
                    }
                    &Opcode::Ceil => {
                        match v2.0 {
                            F32 => {
                                let mut v34 = C::inst_data_etor_returns::default();
                                C::inst_data_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 v669,
                                            imm: v670,
                                        } = &v35.1 {
                                            if let &Opcode::F32const = v669 {
                                                let v773 = C::f32_ceil(ctx, v670);
                                                if let Some(v774) = v773 {
                                                    let v775 = constructor_f32const(ctx, F32, v774);
                                                    let v776 = C::subsume(ctx, v775);
                                                    // Rule at src/opts/cprop.isle line 324.
                                                    returns.extend(Some(v776));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            F64 => {
                                let mut v34 = C::inst_data_etor_returns::default();
                                C::inst_data_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 v675,
                                            imm: v676,
                                        } = &v35.1 {
                                            if let &Opcode::F64const = v675 {
                                                let v777 = C::f64_ceil(ctx, v676);
                                                if let Some(v778) = v777 {
                                                    let v779 = constructor_f64const(ctx, F64, v778);
                                                    let v780 = C::subsume(ctx, v779);
                                                    // Rule at src/opts/cprop.isle line 327.
                                                    returns.extend(Some(v780));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            _ => {}
                        }
                    }
                    &Opcode::Floor => {
                        match v2.0 {
                            F32 => {
                                let mut v34 = C::inst_data_etor_returns::default();
                                C::inst_data_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 v669,
                                            imm: v670,
                                        } = &v35.1 {
                                            if let &Opcode::F32const = v669 {
                                                let v781 = C::f32_floor(ctx, v670);
                                                if let Some(v782) = v781 {
                                                    let v783 = constructor_f32const(ctx, F32, v782);
                                                    let v784 = C::subsume(ctx, v783);
                                                    // Rule at src/opts/cprop.isle line 331.
                                                    returns.extend(Some(v784));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            F64 => {
                                let mut v34 = C::inst_data_etor_returns::default();
                                C::inst_data_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 v675,
                                            imm: v676,
                                        } = &v35.1 {
                                            if let &Opcode::F64const = v675 {
                                                let v785 = C::f64_floor(ctx, v676);
                                                if let Some(v786) = v785 {
                                                    let v787 = constructor_f64const(ctx, F64, v786);
                                                    let v788 = C::subsume(ctx, v787);
                                                    // Rule at src/opts/cprop.isle line 334.
                                                    returns.extend(Some(v788));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            _ => {}
                        }
                    }
                    &Opcode::Trunc => {
                        match v2.0 {
                            F32 => {
                                let mut v34 = C::inst_data_etor_returns::default();
                                C::inst_data_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 v669,
                                            imm: v670,
                                        } = &v35.1 {
                                            if let &Opcode::F32const = v669 {
                                                let v789 = C::f32_trunc(ctx, v670);
                                                if let Some(v790) = v789 {
                                                    let v791 = constructor_f32const(ctx, F32, v790);
                                                    let v792 = C::subsume(ctx, v791);
                                                    // Rule at src/opts/cprop.isle line 338.
                                                    returns.extend(Some(v792));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            F64 => {
                                let mut v34 = C::inst_data_etor_returns::default();
                                C::inst_data_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 v675,
                                            imm: v676,
                                        } = &v35.1 {
                                            if let &Opcode::F64const = v675 {
                                                let v793 = C::f64_trunc(ctx, v676);
                                                if let Some(v794) = v793 {
                                                    let v795 = constructor_f64const(ctx, F64, v794);
                                                    let v796 = C::subsume(ctx, v795);
                                                    // Rule at src/opts/cprop.isle line 341.
                                                    returns.extend(Some(v796));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            _ => {}
                        }
                    }
                    &Opcode::Nearest => {
                        match v2.0 {
                            F32 => {
                                let mut v34 = C::inst_data_etor_returns::default();
                                C::inst_data_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 v669,
                                            imm: v670,
                                        } = &v35.1 {
                                            if let &Opcode::F32const = v669 {
                                                let v797 = C::f32_nearest(ctx, v670);
                                                if let Some(v798) = v797 {
                                                    let v799 = constructor_f32const(ctx, F32, v798);
                                                    let v800 = C::subsume(ctx, v799);
                                                    // Rule at src/opts/cprop.isle line 345.
                                                    returns.extend(Some(v800));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            F64 => {
                                let mut v34 = C::inst_data_etor_returns::default();
                                C::inst_data_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 v675,
                                            imm: v676,
                                        } = &v35.1 {
                                            if let &Opcode::F64const = v675 {
                                                let v801 = C::f64_nearest(ctx, v676);
                                                if let Some(v802) = v801 {
                                                    let v803 = constructor_f64const(ctx, F64, v802);
                                                    let v804 = C::subsume(ctx, v803);
                                                    // Rule at src/opts/cprop.isle line 348.
                                                    returns.extend(Some(v804));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            _ => {}
                        }
                    }
                    &Opcode::Bmask => {
                        if v2.0 == I8 {
                            let mut v34 = C::inst_data_etor_returns::default();
                            C::inst_data_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 v239,
                                        args: ref v240,
                                        cond: ref v241,
                                    } = &v35.1 {
                                        if let &Opcode::Icmp = v239 {
                                            let v246 = constructor_ineg(ctx, I8, v33);
                                            // Rule at src/opts/bitops.isle line 94.
                                            returns.extend(Some(v246));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                            }
                        }
                        let mut v247 = ContextIterWrapper::<ConstructorVec<_>, _>::default();
                        constructor_truthy(ctx, v33, &mut v247);
                        let mut v247 = v247.into_context_iter();
                        while let Some(v248) = v247.next(ctx) {
                            let v249 = constructor_bmask(ctx, v2.0, v248);
                            // Rule at src/opts/bitops.isle line 116.
                            returns.extend(Some(v249));
                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                        }
                    }
                    &Opcode::Ireduce => {
                        let mut v34 = C::inst_data_etor_returns::default();
                        C::inst_data_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 v946 = constructor_ireduce(ctx, v2.0, v40.0);
                                            let v947 = constructor_ireduce(ctx, v2.0, v40.1);
                                            let v948 = constructor_iadd(ctx, v2.0, v946, v947);
                                            // Rule at src/opts/extends.isle line 85.
                                            returns.extend(Some(v948));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Isub => {
                                            let v40 = C::unpack_value_array_2(ctx, v39);
                                            let v946 = constructor_ireduce(ctx, v2.0, v40.0);
                                            let v947 = constructor_ireduce(ctx, v2.0, v40.1);
                                            let v949 = constructor_isub(ctx, v2.0, v946, v947);
                                            // Rule at src/opts/extends.isle line 86.
                                            returns.extend(Some(v949));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Imul => {
                                            let v40 = C::unpack_value_array_2(ctx, v39);
                                            let v946 = constructor_ireduce(ctx, v2.0, v40.0);
                                            let v947 = constructor_ireduce(ctx, v2.0, v40.1);
                                            let v950 = constructor_imul(ctx, v2.0, v946, v947);
                                            // Rule at src/opts/extends.isle line 87.
                                            returns.extend(Some(v950));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Band => {
                                            let v40 = C::unpack_value_array_2(ctx, v39);
                                            let v946 = constructor_ireduce(ctx, v2.0, v40.0);
                                            let v947 = constructor_ireduce(ctx, v2.0, v40.1);
                                            let v953 = constructor_band(ctx, v2.0, v946, v947);
                                            // Rule at src/opts/extends.isle line 90.
                                            returns.extend(Some(v953));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Bor => {
                                            let v40 = C::unpack_value_array_2(ctx, v39);
                                            let v946 = constructor_ireduce(ctx, v2.0, v40.0);
                                            let v947 = constructor_ireduce(ctx, v2.0, v40.1);
                                            let v951 = constructor_bor(ctx, v2.0, v946, v947);
                                            // Rule at src/opts/extends.isle line 88.
                                            returns.extend(Some(v951));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Bxor => {
                                            let v40 = C::unpack_value_array_2(ctx, v39);
                                            let v946 = constructor_ireduce(ctx, v2.0, v40.0);
                                            let v947 = constructor_ireduce(ctx, v2.0, v40.1);
                                            let v952 = constructor_bxor(ctx, v2.0, v946, v947);
                                            // Rule at src/opts/extends.isle line 89.
                                            returns.extend(Some(v952));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v45,
                                    arg: v46,
                                } => {
                                    match v45 {
                                        &Opcode::Ineg => {
                                            let v943 = constructor_ireduce(ctx, v2.0, v46);
                                            let v944 = constructor_ineg(ctx, v2.0, v943);
                                            // Rule at src/opts/extends.isle line 82.
                                            returns.extend(Some(v944));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Bnot => {
                                            let v943 = constructor_ireduce(ctx, v2.0, v46);
                                            let v945 = constructor_bnot(ctx, v2.0, v943);
                                            // Rule at src/opts/extends.isle line 83.
                                            returns.extend(Some(v945));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Bmask => {
                                            let v273 = constructor_bmask(ctx, v2.0, v46);
                                            // Rule at src/opts/bitops.isle line 130.
                                            returns.extend(Some(v273));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Uextend => {
                                            let v52 = C::ty_int(ctx, v2.0);
                                            if let Some(v53) = v52 {
                                                let v929 = C::ty_bits_u64(ctx, v53);
                                                let v928 = C::value_type(ctx, v46);
                                                let v930 = C::ty_bits_u64(ctx, v928);
                                                let v931 = C::u64_lt(ctx, v929, v930);
                                                if v931 == true {
                                                    let v932 = constructor_ireduce(ctx, v53, v46);
                                                    // Rule at src/opts/extends.isle line 57.
                                                    returns.extend(Some(v932));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let v933 = C::u64_lt(ctx, v930, v929);
                                                if v933 == true {
                                                    let v935 = constructor_uextend(ctx, v53, v46);
                                                    // Rule at src/opts/extends.isle line 64.
                                                    returns.extend(Some(v935));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                            let v928 = C::value_type(ctx, v46);
                                            if v2.0 == v928 {
                                                let v47 = C::subsume(ctx, v46);
                                                // Rule at src/opts/extends.isle line 50.
                                                returns.extend(Some(v47));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        &Opcode::Sextend => {
                                            let v52 = C::ty_int(ctx, v2.0);
                                            if let Some(v53) = v52 {
                                                let v929 = C::ty_bits_u64(ctx, v53);
                                                let v928 = C::value_type(ctx, v46);
                                                let v930 = C::ty_bits_u64(ctx, v928);
                                                let v931 = C::u64_lt(ctx, v929, v930);
                                                if v931 == true {
                                                    let v932 = constructor_ireduce(ctx, v53, v46);
                                                    // Rule at src/opts/extends.isle line 54.
                                                    returns.extend(Some(v932));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let v933 = C::u64_lt(ctx, v930, v929);
                                                if v933 == true {
                                                    let v934 = constructor_sextend(ctx, v53, v46);
                                                    // Rule at src/opts/extends.isle line 61.
                                                    returns.extend(Some(v934));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                            let v928 = C::value_type(ctx, v46);
                                            if v2.0 == v928 {
                                                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 v562,
                                    imm: v563,
                                } => {
                                    if let &Opcode::Iconst = v562 {
                                        let v578 = C::fits_in_64(ctx, v35.0);
                                        if let Some(v579) = v578 {
                                            let v564 = C::u64_from_imm64(ctx, v563);
                                            let v580 = C::imm64_masked(ctx, v2.0, v564);
                                            let v581 = constructor_iconst(ctx, v2.0, v580);
                                            let v582 = C::subsume(ctx, v581);
                                            // Rule at src/opts/cprop.isle line 72.
                                            returns.extend(Some(v582));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                    }
                    &Opcode::SwidenLow => {
                        let mut v34 = C::inst_data_etor_returns::default();
                        C::inst_data_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 v1186 = C::lane_type(ctx, v2.0);
                                    let v1357 = constructor_sextend(ctx, v1186, v46);
                                    let v1358 = constructor_splat(ctx, v2.0, v1357);
                                    // Rule at src/opts/vector.isle line 85.
                                    returns.extend(Some(v1358));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                        }
                    }
                    &Opcode::SwidenHigh => {
                        let mut v34 = C::inst_data_etor_returns::default();
                        C::inst_data_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 v1186 = C::lane_type(ctx, v2.0);
                                    let v1357 = constructor_sextend(ctx, v1186, v46);
                                    let v1358 = constructor_splat(ctx, v2.0, v1357);
                                    // Rule at src/opts/vector.isle line 84.
                                    returns.extend(Some(v1358));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                        }
                    }
                    &Opcode::UwidenLow => {
                        let mut v34 = C::inst_data_etor_returns::default();
                        C::inst_data_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 v1186 = C::lane_type(ctx, v2.0);
                                    let v1359 = constructor_uextend(ctx, v1186, v46);
                                    let v1360 = constructor_splat(ctx, v2.0, v1359);
                                    // Rule at src/opts/vector.isle line 88.
                                    returns.extend(Some(v1360));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                        }
                    }
                    &Opcode::UwidenHigh => {
                        let mut v34 = C::inst_data_etor_returns::default();
                        C::inst_data_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 v1186 = C::lane_type(ctx, v2.0);
                                    let v1359 = constructor_uextend(ctx, v1186, v46);
                                    let v1360 = constructor_splat(ctx, v2.0, v1359);
                                    // Rule at src/opts/vector.isle line 87.
                                    returns.extend(Some(v1360));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                        }
                    }
                    &Opcode::Uextend => {
                        let mut v34 = C::inst_data_etor_returns::default();
                        C::inst_data_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 v898 = constructor_uextend(ctx, v2.0, v46);
                                        // Rule at src/opts/extends.isle line 1.
                                        returns.extend(Some(v898));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v562,
                                    imm: v563,
                                } => {
                                    if let &Opcode::Iconst = v562 {
                                        let v526 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v527) = v526 {
                                            let v564 = C::u64_from_imm64(ctx, v563);
                                            let v583 = constructor_iconst_u(ctx, v527, v564);
                                            let v584 = C::subsume(ctx, v583);
                                            // Rule at src/opts/cprop.isle line 77.
                                            returns.extend(Some(v584));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                    }
                    &Opcode::Sextend => {
                        let mut v34 = C::inst_data_etor_returns::default();
                        C::inst_data_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 v239,
                                    args: ref v240,
                                    cond: ref v241,
                                } => {
                                    if let &Opcode::Icmp = v239 {
                                        let v900 = constructor_uextend(ctx, v2.0, v33);
                                        // Rule at src/opts/extends.isle line 11.
                                        returns.extend(Some(v900));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v45,
                                    arg: v46,
                                } => {
                                    match v45 {
                                        &Opcode::Bmask => {
                                            let v273 = constructor_bmask(ctx, v2.0, v46);
                                            // Rule at src/opts/bitops.isle line 129.
                                            returns.extend(Some(v273));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Uextend => {
                                            let v898 = constructor_uextend(ctx, v2.0, v46);
                                            // Rule at src/opts/extends.isle line 7.
                                            returns.extend(Some(v898));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Sextend => {
                                            let v899 = constructor_sextend(ctx, v2.0, v46);
                                            // Rule at src/opts/extends.isle line 3.
                                            returns.extend(Some(v899));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        _ => {}
                                    }
                                }
                                _ => {}
                            }
                        }
                        let v526 = C::fits_in_64(ctx, v2.0);
                        if let Some(v527) = v526 {
                            let mut v585 = C::inst_data_tupled_etor_returns::default();
                            C::inst_data_tupled_etor(ctx, v33, &mut v585);
                            let mut v585 = v585.into_context_iter();
                            while let Some(v586) = v585.next(ctx) {
                                let v587 = C::iconst_sextend_etor(ctx, v586);
                                if let Some(v588) = v587 {
                                    let v591 = constructor_iconst_s(ctx, v527, v588.1);
                                    let v592 = C::subsume(ctx, v591);
                                    // Rule at src/opts/cprop.isle line 79.
                                    returns.extend(Some(v592));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                        }
                    }
                    &Opcode::FcvtFromUint => {
                        let mut v34 = C::inst_data_etor_returns::default();
                        C::inst_data_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 v1186 = C::lane_type(ctx, v2.0);
                                            let v1309 = constructor_fcvt_from_uint(ctx, v1186, v46);
                                            let v1310 = constructor_splat(ctx, v2.0, v1309);
                                            // Rule at src/opts/vector.isle line 6.
                                            returns.extend(Some(v1310));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Uextend => {
                                            let v215 = constructor_fcvt_from_uint(ctx, v2.0, v46);
                                            // Rule at src/opts/arithmetic.isle line 236.
                                            returns.extend(Some(v215));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v562,
                                    imm: v563,
                                } => {
                                    if let &Opcode::Iconst = v562 {
                                        match v2.0 {
                                            F32 => {
                                                let v564 = C::u64_from_imm64(ctx, v563);
                                                let v704 = C::f32_from_uint(ctx, v564);
                                                let v705 = constructor_f32const(ctx, F32, v704);
                                                // Rule at src/opts/cprop.isle line 247.
                                                returns.extend(Some(v705));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            F64 => {
                                                let v564 = C::u64_from_imm64(ctx, v563);
                                                let v707 = C::f64_from_uint(ctx, v564);
                                                let v708 = constructor_f64const(ctx, F64, v707);
                                                // Rule at src/opts/cprop.isle line 249.
                                                returns.extend(Some(v708));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            _ => {}
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                    }
                    &Opcode::FcvtFromSint => {
                        match v2.0 {
                            F32 => {
                                let mut v585 = C::inst_data_tupled_etor_returns::default();
                                C::inst_data_tupled_etor(ctx, v33, &mut v585);
                                let mut v585 = v585.into_context_iter();
                                while let Some(v586) = v585.next(ctx) {
                                    let v587 = C::iconst_sextend_etor(ctx, v586);
                                    if let Some(v588) = v587 {
                                        let v709 = C::f32_from_sint(ctx, v588.1);
                                        let v710 = constructor_f32const(ctx, F32, v709);
                                        // Rule at src/opts/cprop.isle line 251.
                                        returns.extend(Some(v710));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                            }
                            F64 => {
                                let mut v585 = C::inst_data_tupled_etor_returns::default();
                                C::inst_data_tupled_etor(ctx, v33, &mut v585);
                                let mut v585 = v585.into_context_iter();
                                while let Some(v586) = v585.next(ctx) {
                                    let v587 = C::iconst_sextend_etor(ctx, v586);
                                    if let Some(v588) = v587 {
                                        let v711 = C::f64_from_sint(ctx, v588.1);
                                        let v712 = constructor_f64const(ctx, F64, v711);
                                        // Rule at src/opts/cprop.isle line 253.
                                        returns.extend(Some(v712));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                            }
                            _ => {}
                        }
                        let mut v34 = C::inst_data_etor_returns::default();
                        C::inst_data_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 v1186 = C::lane_type(ctx, v2.0);
                                        let v1311 = constructor_fcvt_from_sint(ctx, v1186, v46);
                                        let v1312 = constructor_splat(ctx, v2.0, v1311);
                                        // Rule at src/opts/vector.isle line 8.
                                        returns.extend(Some(v1312));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                    &Opcode::Sextend => {
                                        let v216 = constructor_fcvt_from_sint(ctx, v2.0, v46);
                                        // Rule at src/opts/arithmetic.isle line 238.
                                        returns.extend(Some(v216));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                    _ => {}
                                }
                            }
                        }
                    }
                    _ => {}
                }
            }
            &InstructionData::UnaryIeee32 {
                opcode: ref v1080,
                imm: v1081,
            } => {
                if let &Opcode::F32const = v1080 {
                    let v1077 = C::remat(ctx, arg0);
                    // Rule at src/opts/remat.isle line 27.
                    returns.extend(Some(v1077));
                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                }
            }
            &InstructionData::UnaryIeee64 {
                opcode: ref v1082,
                imm: v1083,
            } => {
                if let &Opcode::F64const = v1082 {
                    let v1077 = C::remat(ctx, arg0);
                    // Rule at src/opts/remat.isle line 29.
                    returns.extend(Some(v1077));
                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                }
            }
            &InstructionData::UnaryImm {
                opcode: ref v1078,
                imm: v1079,
            } => {
                if let &Opcode::Iconst = v1078 {
                    let v1077 = C::remat(ctx, arg0);
                    // Rule at src/opts/remat.isle line 25.
                    returns.extend(Some(v1077));
                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                }
            }
            _ => {}
        }
    }
}

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

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

// 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 115.
        return arg1;
    }
    let v2 = constructor_uextend(ctx, arg0, arg1);
    // Rule at src/prelude_opt.isle line 114.
    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 121.
        return arg1;
    }
    let v2 = constructor_sextend(ctx, arg0, arg1);
    // Rule at src/prelude_opt.isle line 120.
    return v2;
}

// 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_etor_returns::default();
    C::inst_data_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 108.
                        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 109.
                        returns.extend(Some(v9.0));
                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                    }
                    _ => {}
                }
            }
            &InstructionData::IntCompare {
                opcode: ref v33,
                args: ref v34,
                cond: ref v35,
            } => {
                if let &Opcode::Icmp = v33 {
                    if let &IntCC::NotEqual = v35 {
                        let v36 = C::unpack_value_array_2(ctx, v34);
                        let mut v39 = C::inst_data_etor_returns::default();
                        C::inst_data_etor(ctx, v36.1, &mut v39);
                        let mut v39 = v39.into_context_iter();
                        while let Some(v40) = v39.next(ctx) {
                            if let &InstructionData::UnaryImm {
                                opcode: ref v43,
                                imm: v44,
                            } = &v40.1 {
                                if let &Opcode::Iconst = v43 {
                                    let v45 = C::u64_from_imm64(ctx, v44);
                                    if v45 == 0x0_u64 {
                                        // Rule at src/opts/bitops.isle line 112.
                                        returns.extend(Some(v36.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_etor_returns::default();
                    C::inst_data_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_is_zero(ctx, v24);
                                if v25 == false {
                                    let mut v26 = C::inst_data_etor_returns::default();
                                    C::inst_data_etor(ctx, v14.2, &mut v26);
                                    let mut v26 = v26.into_context_iter();
                                    while let Some(v27) = v26.next(ctx) {
                                        if let &InstructionData::UnaryImm {
                                            opcode: ref v30,
                                            imm: v31,
                                        } = &v27.1 {
                                            if let &Opcode::Iconst = v30 {
                                                let v32 = C::u64_from_imm64(ctx, v31);
                                                if v32 == 0x0_u64 {
                                                    // Rule at src/opts/bitops.isle line 110.
                                                    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 104.
                        returns.extend(Some(v6));
                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                    }
                    &Opcode::Bitrev => {
                        // Rule at src/opts/bitops.isle line 106.
                        returns.extend(Some(v6));
                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                    }
                    &Opcode::Bswap => {
                        // Rule at src/opts/bitops.isle line 105.
                        returns.extend(Some(v6));
                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                    }
                    &Opcode::Popcnt => {
                        // Rule at src/opts/bitops.isle line 107.
                        returns.extend(Some(v6));
                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                    }
                    &Opcode::Bmask => {
                        // Rule at src/opts/bitops.isle line 103.
                        returns.extend(Some(v6));
                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                    }
                    &Opcode::Uextend => {
                        // Rule at src/opts/bitops.isle line 102.
                        returns.extend(Some(v6));
                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                    }
                    &Opcode::Sextend => {
                        // Rule at src/opts/bitops.isle line 101.
                        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_u64);
    let v3 = C::u64_or(ctx, arg0, v2);
    let v4 = constructor_splat16(ctx, v3);
    // Rule at src/opts/cprop.isle line 200.
    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_u64);
    let v3 = C::u64_or(ctx, arg0, v2);
    let v4 = constructor_splat32(ctx, v3);
    // Rule at src/opts/cprop.isle line 202.
    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_u64);
    let v3 = C::u64_or(ctx, arg0, v2);
    let v4 = C::splat64(ctx, v3);
    // Rule at src/opts/cprop.isle line 204.
    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_is_zero(ctx, v4);
    if v5 == false {
        let v7 = C::u64_eq(ctx, 0x2_u64, v4);
        let v8 = Some(v7);
        // Rule at src/opts/icmp.isle line 174.
        return v8;
    }
    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 179.
            return 0x1_u64;
        }
        &IntCC::NotEqual => {
            // Rule at src/opts/icmp.isle line 188.
            return 0x6_u64;
        }
        &IntCC::SignedGreaterThan => {
            // Rule at src/opts/icmp.isle line 185.
            return 0x4_u64;
        }
        &IntCC::SignedGreaterThanOrEqual => {
            // Rule at src/opts/icmp.isle line 187.
            return 0x5_u64;
        }
        &IntCC::SignedLessThan => {
            // Rule at src/opts/icmp.isle line 181.
            return 0x2_u64;
        }
        &IntCC::SignedLessThanOrEqual => {
            // Rule at src/opts/icmp.isle line 183.
            return 0x3_u64;
        }
        &IntCC::UnsignedGreaterThan => {
            // Rule at src/opts/icmp.isle line 184.
            return 0x4_u64;
        }
        &IntCC::UnsignedGreaterThanOrEqual => {
            // Rule at src/opts/icmp.isle line 186.
            return 0x5_u64;
        }
        &IntCC::UnsignedLessThan => {
            // Rule at src/opts/icmp.isle line 180.
            return 0x2_u64;
        }
        &IntCC::UnsignedLessThanOrEqual => {
            // Rule at src/opts/icmp.isle line 182.
            return 0x3_u64;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "decompose_intcc", "src/opts/icmp.isle line 178")
}

// 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 191.
            return v7;
        }
        0x1_u64 => {
            let v9 = constructor_icmp(ctx, arg0, &IntCC::Equal, arg3, arg4);
            // Rule at src/opts/icmp.isle line 192.
            return v9;
        }
        0x2_u64 => {
            match arg2 {
                false => {
                    let v11 = constructor_icmp(ctx, arg0, &IntCC::UnsignedLessThan, arg3, arg4);
                    // Rule at src/opts/icmp.isle line 193.
                    return v11;
                }
                true => {
                    let v13 = constructor_icmp(ctx, arg0, &IntCC::SignedLessThan, arg3, arg4);
                    // Rule at src/opts/icmp.isle line 194.
                    return v13;
                }
                _ => {}
            }
        }
        0x3_u64 => {
            match arg2 {
                false => {
                    let v15 = constructor_icmp(ctx, arg0, &IntCC::UnsignedLessThanOrEqual, arg3, arg4);
                    // Rule at src/opts/icmp.isle line 195.
                    return v15;
                }
                true => {
                    let v17 = constructor_icmp(ctx, arg0, &IntCC::SignedLessThanOrEqual, arg3, arg4);
                    // Rule at src/opts/icmp.isle line 196.
                    return v17;
                }
                _ => {}
            }
        }
        0x4_u64 => {
            match arg2 {
                false => {
                    let v19 = constructor_icmp(ctx, arg0, &IntCC::UnsignedGreaterThan, arg3, arg4);
                    // Rule at src/opts/icmp.isle line 197.
                    return v19;
                }
                true => {
                    let v21 = constructor_icmp(ctx, arg0, &IntCC::SignedGreaterThan, arg3, arg4);
                    // Rule at src/opts/icmp.isle line 198.
                    return v21;
                }
                _ => {}
            }
        }
        0x5_u64 => {
            match arg2 {
                false => {
                    let v23 = constructor_icmp(ctx, arg0, &IntCC::UnsignedGreaterThanOrEqual, arg3, arg4);
                    // Rule at src/opts/icmp.isle line 199.
                    return v23;
                }
                true => {
                    let v25 = constructor_icmp(ctx, arg0, &IntCC::SignedGreaterThanOrEqual, arg3, arg4);
                    // Rule at src/opts/icmp.isle line 200.
                    return v25;
                }
                _ => {}
            }
        }
        0x6_u64 => {
            let v27 = constructor_icmp(ctx, arg0, &IntCC::NotEqual, arg3, arg4);
            // Rule at src/opts/icmp.isle line 201.
            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 202.
            return v30;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "compose_icmp", "src/opts/icmp.isle line 190")
}

// 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 213.
            return 0x3_u64;
        }
        &IntCC::NotEqual => {
            // Rule at src/opts/icmp.isle line 214.
            return 0x3_u64;
        }
        &IntCC::SignedGreaterThan => {
            // Rule at src/opts/icmp.isle line 211.
            return 0x2_u64;
        }
        &IntCC::SignedGreaterThanOrEqual => {
            // Rule at src/opts/icmp.isle line 212.
            return 0x2_u64;
        }
        &IntCC::SignedLessThan => {
            // Rule at src/opts/icmp.isle line 209.
            return 0x2_u64;
        }
        &IntCC::SignedLessThanOrEqual => {
            // Rule at src/opts/icmp.isle line 210.
            return 0x2_u64;
        }
        &IntCC::UnsignedGreaterThan => {
            // Rule at src/opts/icmp.isle line 207.
            return 0x1_u64;
        }
        &IntCC::UnsignedGreaterThanOrEqual => {
            // Rule at src/opts/icmp.isle line 208.
            return 0x1_u64;
        }
        &IntCC::UnsignedLessThan => {
            // Rule at src/opts/icmp.isle line 205.
            return 0x1_u64;
        }
        &IntCC::UnsignedLessThanOrEqual => {
            // Rule at src/opts/icmp.isle line 206.
            return 0x1_u64;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "intcc_class", "src/opts/icmp.isle line 204")
}

// 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 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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 358.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 367.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 376.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 385.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 394.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 403.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 412.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 421.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 430.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 439.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 448.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 457.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 466.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 475.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 484.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 493.
    return v6;
}

// 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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 502.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 511.
    return v6;
}

// 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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 520.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 529.
    return v6;
}

// 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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 538.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 547.
    return v6;
}

// Generated as internal constructor for term stack_switch.
pub fn constructor_stack_switch<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::StackSwitch,
        args: v5.clone(),
    };
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);
    // Rule at /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 556.
    return v7;
}

// 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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 565.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 574.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 583.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 592.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 601.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 610.
    return v6;
}

// Generated as internal constructor for term stack_load.
pub fn constructor_stack_load<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: StackSlot,
    arg2: Offset32,
) -> Value {
    let v4 = InstructionData::StackLoad {
        opcode: Opcode::StackLoad,
        stack_slot: arg1,
        offset: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 619.
    return v5;
}

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

// Generated as internal constructor for term dynamic_stack_load.
pub fn constructor_dynamic_stack_load<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: DynamicStackSlot,
) -> Value {
    let v3 = InstructionData::DynamicStackLoad {
        opcode: Opcode::DynamicStackLoad,
        dynamic_stack_slot: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 637.
    return v4;
}

// Generated as internal constructor for term dynamic_stack_addr.
pub fn constructor_dynamic_stack_addr<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: DynamicStackSlot,
) -> Value {
    let v3 = InstructionData::DynamicStackLoad {
        opcode: Opcode::DynamicStackAddr,
        dynamic_stack_slot: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 646.
    return v4;
}

// Generated as internal constructor for term global_value.
pub fn constructor_global_value<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: GlobalValue,
) -> Value {
    let v3 = InstructionData::UnaryGlobalValue {
        opcode: Opcode::GlobalValue,
        global_value: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 655.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 664.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 673.
    return v4;
}

// Generated as internal constructor for term get_pinned_reg.
pub fn constructor_get_pinned_reg<C: Context>(
    ctx: &mut C,
    arg0: Type,
) -> Value {
    let v2 = InstructionData::NullAry {
        opcode: Opcode::GetPinnedReg,
    };
    let v3 = C::make_inst_ctor(ctx, arg0, &v2);
    // Rule at /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 682.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 691.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 700.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 709.
    return v3;
}

// 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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 718.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 727.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 736.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 745.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 754.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 763.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 772.
    return v7;
}

// 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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 781.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 790.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 799.
    return v7;
}

// Generated as internal constructor for term x86_blendv.
pub fn constructor_x86_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::X86Blendv,
        args: v5.clone(),
    };
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);
    // Rule at /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 808.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 817.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 826.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 835.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 844.
    return v7;
}

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

// Generated as internal constructor for term iadd.
pub fn constructor_iadd<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Iadd,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 862.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 871.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 880.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 889.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 898.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 907.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 916.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 925.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 934.
    return v6;
}

// Generated as internal constructor for term udiv.
pub fn constructor_udiv<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::Udiv,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 943.
    return v6;
}

// Generated as internal constructor for term sdiv.
pub fn constructor_sdiv<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::Sdiv,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 952.
    return v6;
}

// Generated as internal constructor for term urem.
pub fn constructor_urem<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::Urem,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 961.
    return v6;
}

// Generated as internal constructor for term srem.
pub fn constructor_srem<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::Srem,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 970.
    return v6;
}

// Generated as internal constructor for term iadd_imm.
pub fn constructor_iadd_imm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Imm64,
) -> Value {
    let v4 = InstructionData::BinaryImm64 {
        opcode: Opcode::IaddImm,
        arg: arg1,
        imm: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 979.
    return v5;
}

// Generated as internal constructor for term imul_imm.
pub fn constructor_imul_imm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Imm64,
) -> Value {
    let v4 = InstructionData::BinaryImm64 {
        opcode: Opcode::ImulImm,
        arg: arg1,
        imm: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 988.
    return v5;
}

// Generated as internal constructor for term udiv_imm.
pub fn constructor_udiv_imm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Imm64,
) -> Value {
    let v4 = InstructionData::BinaryImm64 {
        opcode: Opcode::UdivImm,
        arg: arg1,
        imm: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 997.
    return v5;
}

// Generated as internal constructor for term sdiv_imm.
pub fn constructor_sdiv_imm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Imm64,
) -> Value {
    let v4 = InstructionData::BinaryImm64 {
        opcode: Opcode::SdivImm,
        arg: arg1,
        imm: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1006.
    return v5;
}

// Generated as internal constructor for term urem_imm.
pub fn constructor_urem_imm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Imm64,
) -> Value {
    let v4 = InstructionData::BinaryImm64 {
        opcode: Opcode::UremImm,
        arg: arg1,
        imm: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1015.
    return v5;
}

// Generated as internal constructor for term srem_imm.
pub fn constructor_srem_imm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Imm64,
) -> Value {
    let v4 = InstructionData::BinaryImm64 {
        opcode: Opcode::SremImm,
        arg: arg1,
        imm: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1024.
    return v5;
}

// Generated as internal constructor for term irsub_imm.
pub fn constructor_irsub_imm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Imm64,
) -> Value {
    let v4 = InstructionData::BinaryImm64 {
        opcode: Opcode::IrsubImm,
        arg: arg1,
        imm: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1033.
    return v5;
}

// Generated as internal constructor for term uadd_overflow_trap.
pub fn constructor_uadd_overflow_trap<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
    arg3: &TrapCode,
) -> Value {
    let v5 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v6 = InstructionData::IntAddTrap {
        opcode: Opcode::UaddOverflowTrap,
        args: v5.clone(),
        code: arg3.clone(),
    };
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);
    // Rule at /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1042.
    return v7;
}

// 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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1051.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1060.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1069.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1078.
    return v4;
}

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

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

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

// Generated as internal constructor for term band_imm.
pub fn constructor_band_imm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Imm64,
) -> Value {
    let v4 = InstructionData::BinaryImm64 {
        opcode: Opcode::BandImm,
        arg: arg1,
        imm: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1114.
    return v5;
}

// Generated as internal constructor for term bor_imm.
pub fn constructor_bor_imm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Imm64,
) -> Value {
    let v4 = InstructionData::BinaryImm64 {
        opcode: Opcode::BorImm,
        arg: arg1,
        imm: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1123.
    return v5;
}

// Generated as internal constructor for term bxor_imm.
pub fn constructor_bxor_imm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Imm64,
) -> Value {
    let v4 = InstructionData::BinaryImm64 {
        opcode: Opcode::BxorImm,
        arg: arg1,
        imm: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1132.
    return v5;
}

// Generated as internal constructor for term rotl.
pub fn constructor_rotl<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Rotl,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1141.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1150.
    return v6;
}

// Generated as internal constructor for term rotl_imm.
pub fn constructor_rotl_imm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Imm64,
) -> Value {
    let v4 = InstructionData::BinaryImm64 {
        opcode: Opcode::RotlImm,
        arg: arg1,
        imm: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1159.
    return v5;
}

// Generated as internal constructor for term rotr_imm.
pub fn constructor_rotr_imm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Imm64,
) -> Value {
    let v4 = InstructionData::BinaryImm64 {
        opcode: Opcode::RotrImm,
        arg: arg1,
        imm: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1168.
    return v5;
}

// Generated as internal constructor for term ishl.
pub fn constructor_ishl<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Ishl,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1177.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1186.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1195.
    return v6;
}

// Generated as internal constructor for term ishl_imm.
pub fn constructor_ishl_imm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Imm64,
) -> Value {
    let v4 = InstructionData::BinaryImm64 {
        opcode: Opcode::IshlImm,
        arg: arg1,
        imm: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1204.
    return v5;
}

// Generated as internal constructor for term ushr_imm.
pub fn constructor_ushr_imm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Imm64,
) -> Value {
    let v4 = InstructionData::BinaryImm64 {
        opcode: Opcode::UshrImm,
        arg: arg1,
        imm: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1213.
    return v5;
}

// Generated as internal constructor for term sshr_imm.
pub fn constructor_sshr_imm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Imm64,
) -> Value {
    let v4 = InstructionData::BinaryImm64 {
        opcode: Opcode::SshrImm,
        arg: arg1,
        imm: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1222.
    return v5;
}

// Generated as internal constructor for term bitrev.
pub fn constructor_bitrev<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::Bitrev,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1231.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1240.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1249.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1258.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1267.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1276.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1285.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1294.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1303.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1312.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1321.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1330.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1339.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1348.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1357.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1366.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1375.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1384.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1393.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1402.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1411.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1420.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1429.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1438.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1447.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1456.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1465.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1474.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1483.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1492.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1501.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1510.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1519.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1528.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1537.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1546.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1555.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1564.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1573.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1582.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1591.
    return v4;
}

// Generated as internal constructor for term fcvt_to_uint.
pub fn constructor_fcvt_to_uint<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::FcvtToUint,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1600.
    return v4;
}

// Generated as internal constructor for term fcvt_to_sint.
pub fn constructor_fcvt_to_sint<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::FcvtToSint,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1609.
    return v4;
}

// 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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1618.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1627.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1636.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1645.
    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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1654.
    return v4;
}

// 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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1663.
    return v6;
}

// Generated as internal constructor for term atomic_rmw.
pub fn constructor_atomic_rmw<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: MemFlags,
    arg2: &AtomicRmwOp,
    arg3: Value,
    arg4: Value,
) -> Value {
    let v6 = &C::value_array_2_ctor(ctx, arg3, arg4);
    let v7 = InstructionData::AtomicRmw {
        opcode: Opcode::AtomicRmw,
        args: v6.clone(),
        flags: arg1,
        op: arg2.clone(),
    };
    let v8 = C::make_inst_ctor(ctx, arg0, &v7);
    // Rule at /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1672.
    return v8;
}

// Generated as internal constructor for term atomic_cas.
pub fn constructor_atomic_cas<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: MemFlags,
    arg2: Value,
    arg3: Value,
    arg4: Value,
) -> Value {
    let v6 = &C::value_array_3_ctor(ctx, arg2, arg3, arg4);
    let v7 = InstructionData::AtomicCas {
        opcode: Opcode::AtomicCas,
        args: v6.clone(),
        flags: arg1,
    };
    let v8 = C::make_inst_ctor(ctx, arg0, &v7);
    // Rule at /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1681.
    return v8;
}

// Generated as internal constructor for term atomic_load.
pub fn constructor_atomic_load<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: MemFlags,
    arg2: Value,
) -> Value {
    let v4 = InstructionData::LoadNoOffset {
        opcode: Opcode::AtomicLoad,
        arg: arg2,
        flags: arg1,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1690.
    return v5;
}

// 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 /build/deno/src/deno/target/release/build/cranelift-codegen-858815359f46c3f9/out/clif_opt.isle line 1699.
    return v5;
}
