// SPDX-License-Identifier: LGPL-3.0-or-later
// See Notices.txt for copyright information

use crate::{
    intern::{Intern, Interned, Memoize},
    source_location::SourceLocation,
    ty::CanonicalType,
    util::get_many_mut,
};
use hashbrown::HashMap;
use num_bigint::BigInt;
use num_traits::{One, Signed, ToPrimitive, Zero};
use std::{
    borrow::BorrowMut,
    convert::Infallible,
    fmt,
    hash::{Hash, Hasher},
    marker::PhantomData,
    ops::{Deref, DerefMut, Index, IndexMut},
};
use vec_map::VecMap;

pub(crate) type SmallUInt = u64;
pub(crate) type SmallSInt = i64;
pub(crate) const MIN_BITS_FOR_NEEDING_BIG: usize = SmallUInt::BITS as usize + 1;

#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
pub(crate) enum InsnFieldKind {
    Input,
    Output,
    Immediate,
    BranchTarget,
}

pub(crate) trait InsnFieldTypeTransform: Eq + Hash + fmt::Debug + Send + Sync {
    type Type<FieldType: InsnFieldTrait>: Eq + Hash + fmt::Debug + Send + Sync;
    fn empty_type() -> Self::Type<[(); 0]>;
}

#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, Default)]
pub(crate) struct InsnFieldTypeTransformUnit;

impl InsnFieldTypeTransform for InsnFieldTypeTransformUnit {
    type Type<FieldType: InsnFieldTrait> = ();
    fn empty_type() -> Self::Type<[(); 0]> {
        ()
    }
}

#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
pub(crate) struct InsnFieldTypeTransformRef<'a>(PhantomData<&'a ()>);

impl<'a> InsnFieldTypeTransform for InsnFieldTypeTransformRef<'a> {
    type Type<FieldType: InsnFieldTrait> = &'a FieldType;
    fn empty_type() -> Self::Type<[(); 0]> {
        &[]
    }
}

#[derive(PartialEq, Eq, Hash, Debug)]
pub(crate) struct InsnFieldTypeTransformRefMut<'a>(PhantomData<&'a mut ()>);

impl<'a> InsnFieldTypeTransform for InsnFieldTypeTransformRefMut<'a> {
    type Type<FieldType: InsnFieldTrait> = &'a mut FieldType;
    fn empty_type() -> Self::Type<[(); 0]> {
        &mut []
    }
}

#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
pub(crate) struct InsnFieldTypeTransformValue;

impl InsnFieldTypeTransform for InsnFieldTypeTransformValue {
    type Type<FieldType: InsnFieldTrait> = FieldType;
    fn empty_type() -> Self::Type<[(); 0]> {
        []
    }
}

pub trait InsnFieldTrait: Send + Sync + 'static + Copy + Eq + Hash + fmt::Debug {
    const UNIT: InsnFieldType<InsnFieldTypeTransformUnit>;
    fn variant<Transform: InsnFieldTypeTransform>(
        v: Transform::Type<Self>,
    ) -> InsnFieldType<Transform>;
}

macro_rules! insn_field_enum {
    (
        $enum_vis:vis enum $InsnFieldType:ident<$Transform:ident: $InsnFieldTypeTransform:ident> {
            $($Variant:ident($Transform2:ident::$Type:ident<$variant_ty:ty>),)*
        }
    ) => {
        #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
        $enum_vis enum $InsnFieldType<$Transform: $InsnFieldTypeTransform> {
            $($Variant($Transform2::$Type<$variant_ty>),)*
        }

        $(impl InsnFieldTrait for $variant_ty {
            const UNIT: $InsnFieldType<InsnFieldTypeTransformUnit> = $InsnFieldType::$Variant(());
            fn variant<$Transform2: $InsnFieldTypeTransform>(
                v: $Transform2::$Type<Self>,
            ) -> $InsnFieldType<$Transform2> {
                $InsnFieldType::$Variant(v)
            }
        })*
    };
}

insn_field_enum! {
    pub(crate) enum InsnFieldType<Transform: InsnFieldTypeTransform> {
        SmallSlot(Transform::Type<StatePartIndex<StatePartKindSmallSlots>>),
        BigSlot(Transform::Type<StatePartIndex<StatePartKindBigSlots>>),
        SmallSlotArrayIndexed(Transform::Type<StatePartArrayIndexed<StatePartKindSmallSlots>>),
        BigSlotArrayIndexed(Transform::Type<StatePartArrayIndexed<StatePartKindBigSlots>>),
        SmallUInt(Transform::Type<SmallUInt>),
        SmallSInt(Transform::Type<SmallSInt>),
        InternedBigInt(Transform::Type<Interned<BigInt>>),
        U8(Transform::Type<u8>),
        USize(Transform::Type<usize>),
        Empty(Transform::Type<[(); 0]>),
    }
}

impl<Transform: InsnFieldTypeTransform> InsnFieldType<Transform> {
    pub(crate) fn empty() -> Self {
        Self::Empty(Transform::empty_type())
    }
}

#[derive(PartialEq, Eq, Hash, Debug)]
pub(crate) struct InsnField<Transform: InsnFieldTypeTransform> {
    pub(crate) ty: InsnFieldType<Transform>,
    pub(crate) kind: InsnFieldKind,
}

impl<Transform: InsnFieldTypeTransform> Clone for InsnField<Transform>
where
    InsnFieldType<Transform>: Clone,
{
    fn clone(&self) -> Self {
        Self {
            ty: self.ty.clone(),
            kind: self.kind.clone(),
        }
    }
}

impl<Transform: InsnFieldTypeTransform> Copy for InsnField<Transform> where
    InsnFieldType<Transform>: Copy
{
}

fn make_array_into_iter<T, const I: usize, const N: usize>(
    input: [T; I],
    mut default: impl FnMut() -> T,
) -> std::array::IntoIter<T, N> {
    const {
        assert!(I <= N);
    };
    let mut input = input.into_iter();
    let array = std::array::from_fn(|_| input.next().unwrap_or_else(&mut default));
    let mut retval = array.into_iter();
    // remove unneeded trailing elements
    if I < N {
        retval.nth_back(N - I - 1);
    }
    retval
}

impl fmt::Debug for Insn {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.debug_fmt::<InsnsBuildingDone>(f, None, None)
    }
}

impl Insn {
    fn debug_fmt<BK: InsnsBuildingKind>(
        &self,
        f: &mut fmt::Formatter<'_>,
        labels: Option<&Labels>,
        state_layout: Option<&StateLayout<BK>>,
    ) -> fmt::Result {
        let (insn_name, fields) = self.fields_with_names();
        write!(f, "{insn_name}")?;
        if fields.len() == 0 {
            return Ok(());
        }
        writeln!(f, " {{")?;
        for (field_name, field) in fields {
            write!(f, "    {field_name}: ")?;
            match field.kind {
                InsnFieldKind::BranchTarget => match field.ty {
                    InsnFieldType::USize(&label_index) => {
                        if let Some(labels) = labels {
                            write!(f, "L{label_index}")?;
                            if let Some(label) = labels.labels.get(label_index) {
                                if let Some(address) = label.address {
                                    write!(f, " (at {address})")?;
                                } else {
                                    write!(f, " (not yet defined)")?;
                                }
                            } else {
                                write!(f, " (invalid)")?;
                            }
                            writeln!(f, ",")?;
                            continue;
                        }
                    }
                    InsnFieldType::SmallSlot(_)
                    | InsnFieldType::BigSlot(_)
                    | InsnFieldType::SmallSlotArrayIndexed(_)
                    | InsnFieldType::BigSlotArrayIndexed(_)
                    | InsnFieldType::SmallUInt(_)
                    | InsnFieldType::SmallSInt(_)
                    | InsnFieldType::InternedBigInt(_)
                    | InsnFieldType::U8(_)
                    | InsnFieldType::Empty(_) => {}
                },
                InsnFieldKind::Input | InsnFieldKind::Output | InsnFieldKind::Immediate => {}
            }
            match field.ty {
                InsnFieldType::SmallSlot(v) => {
                    v.debug_fmt(f, ",", " // ", "", state_layout)?;
                }
                InsnFieldType::BigSlot(v) => {
                    v.debug_fmt(f, ",", " // ", "", state_layout)?;
                }
                InsnFieldType::SmallSlotArrayIndexed(v) => {
                    v.debug_fmt(f, ",", " // ", "", state_layout)?;
                }
                InsnFieldType::BigSlotArrayIndexed(v) => {
                    v.debug_fmt(f, ",", " // ", "", state_layout)?;
                }
                InsnFieldType::SmallUInt(v) => fmt::Debug::fmt(v, f)?,
                InsnFieldType::SmallSInt(v) => fmt::Debug::fmt(v, f)?,
                InsnFieldType::InternedBigInt(v) => fmt::Debug::fmt(v, f)?,
                InsnFieldType::U8(v) => fmt::Debug::fmt(v, f)?,
                InsnFieldType::USize(v) => fmt::Debug::fmt(v, f)?,
                InsnFieldType::Empty(v) => fmt::Debug::fmt(v, f)?,
            }
            writeln!(f, ",")?;
        }
        write!(f, "}}")
    }
}

macro_rules! impl_insns {
    (
        #[insn = $Insn:ident, next_macro = $next_macro:ident, branch_macro = $branch_macro:ident]
        $vis:vis fn $State:ident::$run:ident(&mut $self:ident) -> $run_ret_ty:ty {
            #[state]
            let mut $state:ident = $state_init:expr;
            setup! {
                $($setup:tt)*
            }
            main_loop!();
            cleanup! {
                $($cleanup:tt)*
            }
        }
        $(
            $(#[$insn_meta:meta])*
            $insn_name:ident $({
                $(
                    #[kind = $field_kind:ident]
                    $(#[$field_meta:meta])*
                    $field_name:ident: $field_ty:ty,
                )*
            })? => $block:block
        )*
    ) => {
        #[derive(Copy, Clone, Eq, PartialEq, Hash)]
        $vis enum $Insn {
            $(
                $(#[$insn_meta])*
                $insn_name $({
                    $(
                        $(#[$field_meta])*
                        $field_name: $field_ty,
                    )*
                })?,
            )*
        }

        impl $Insn {
            $vis const MAX_FIELDS: usize = {
                let mut retval = 0;
                $($(
                    let fields = [$(stringify!($field_name),)*].len();
                    if retval < fields {
                        retval = fields;
                    }
                )?)*
                retval
            };
        }

        impl $Insn {
            $vis const fn fields_unit(&self) -> &'static [InsnField<InsnFieldTypeTransformUnit>] {
                match self {
                    $(
                        $Insn::$insn_name {..} => &[
                            $($(InsnField {
                                ty: <$field_ty as InsnFieldTrait>::UNIT,
                                kind: InsnFieldKind::$field_kind,
                            },)*)?
                        ],
                    )*
                }
            }
            $vis fn fields<'a>(&'a self) -> std::array::IntoIter<InsnField<InsnFieldTypeTransformRef<'a>>, { $Insn::MAX_FIELDS }> {
                match self {
                    $(
                        $Insn::$insn_name $({
                            $($field_name,)*
                        })? => make_array_into_iter([
                                $($(InsnField {
                                    ty: <$field_ty as InsnFieldTrait>::variant($field_name),
                                    kind: InsnFieldKind::$field_kind,
                                },)*)?
                            ],
                            || InsnField {
                                ty: InsnFieldType::empty(),
                                kind: InsnFieldKind::Immediate,
                            },
                        ),
                    )*
                }
            }
            $vis fn fields_with_names<'a>(&'a self) -> (&'static str, std::array::IntoIter<(&'static str, InsnField<InsnFieldTypeTransformRef<'a>>), { $Insn::MAX_FIELDS }>) {
                match self {
                    $(
                        $Insn::$insn_name $({
                            $($field_name,)*
                        })? => (
                            stringify!($insn_name),
                            make_array_into_iter([
                                    $($((stringify!($field_name), InsnField {
                                        ty: <$field_ty as InsnFieldTrait>::variant($field_name),
                                        kind: InsnFieldKind::$field_kind,
                                    }),)*)?
                                ],
                                || ("", InsnField {
                                    ty: InsnFieldType::empty(),
                                    kind: InsnFieldKind::Immediate,
                                }),
                            ),
                        ),
                    )*
                }
            }
            $vis fn fields_mut<'a>(&'a mut self) -> std::array::IntoIter<InsnField<InsnFieldTypeTransformRefMut<'a>>, { $Insn::MAX_FIELDS }> {
                match self {
                    $(
                        $Insn::$insn_name $({
                            $($field_name,)*
                        })? => make_array_into_iter([
                                $($(InsnField {
                                    ty: <$field_ty as InsnFieldTrait>::variant($field_name),
                                    kind: InsnFieldKind::$field_kind,
                                },)*)?
                            ],
                            || InsnField {
                                ty: InsnFieldType::empty(),
                                kind: InsnFieldKind::Immediate,
                            },
                        ),
                    )*
                }
            }
            $vis fn into_fields(self) -> std::array::IntoIter<InsnField<InsnFieldTypeTransformValue>, { $Insn::MAX_FIELDS }> {
                match self {
                    $(
                        $Insn::$insn_name $({
                            $($field_name,)*
                        })? => make_array_into_iter([
                                $($(InsnField {
                                    ty: <$field_ty as InsnFieldTrait>::variant($field_name),
                                    kind: InsnFieldKind::$field_kind,
                                },)*)?
                            ],
                            || InsnField {
                                ty: InsnFieldType::empty(),
                                kind: InsnFieldKind::Immediate,
                            },
                        ),
                    )*
                }
            }
        }

        impl $State {
            $vis fn $run(&mut $self) -> $run_ret_ty {
                let mut $state = $state_init;
                $($setup)*
                let mut insn = $state.insns[$state.pc];
                let retval = 'main_loop: loop {
                    macro_rules! $next_macro {
                        () => {
                            $state.pc += 1;
                            insn = $state.insns[$state.pc];
                            continue 'main_loop;
                        };
                    }
                    macro_rules! $branch_macro {
                        ($next_pc:expr) => {
                            $state.pc = $next_pc;
                            insn = $state.insns[$state.pc];
                            continue 'main_loop;
                        };
                    }
                    let _: Infallible = match insn {
                        $(
                            $Insn::$insn_name $({
                                $(
                                    $field_name,
                                )*
                            })? => {
                                $block
                            }
                        )*
                    };
                };
                $($cleanup)*
                retval
            }
        }
    };
}

pub(crate) trait InsnsBuildingKind: Copy + Eq + fmt::Debug + Hash + Default {
    type Vec<T: fmt::Debug + Clone + Eq + Hash + Send + Sync + 'static>: fmt::Debug
        + Clone
        + Eq
        + Hash
        + Send
        + Sync
        + 'static
        + Default
        + Deref<Target = [T]>
        + FromIterator<T>;
    type Labels: Default;
    fn labels(labels: &Self::Labels) -> Option<&Labels>;
}

#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, Default)]
pub(crate) struct InsnsBuildingDone;

impl InsnsBuildingKind for InsnsBuildingDone {
    type Vec<T: fmt::Debug + Clone + Eq + Hash + Send + Sync + 'static> = Interned<[T]>;
    type Labels = ();
    fn labels(_labels: &Self::Labels) -> Option<&Labels> {
        None
    }
}

#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, Default)]
pub(crate) struct InsnsBuilding;

impl InsnsBuildingKind for InsnsBuilding {
    type Vec<T: fmt::Debug + Clone + Eq + Hash + Send + Sync + 'static> = Vec<T>;
    type Labels = Labels;
    fn labels(labels: &Self::Labels) -> Option<&Labels> {
        Some(labels)
    }
}

struct Label {
    address: Option<usize>,
}

#[derive(Default)]
pub(crate) struct Labels {
    labels: Vec<Label>,
    address_to_label_indexes_map: HashMap<usize, Vec<usize>>,
}

#[derive(Clone, PartialEq, Eq, Hash)]
pub(crate) struct Insns<BK: InsnsBuildingKind> {
    insns: BK::Vec<Insn>,
    insn_source_locations: BK::Vec<SourceLocation>,
    labels: BK::Labels,
    state_layout: StateLayout<BK>,
}

impl<BK: InsnsBuildingKind> Insns<BK> {
    pub(crate) fn state_layout(&self) -> &StateLayout<BK> {
        &self.state_layout
    }
}

struct InsnsDebug<'a, BK: InsnsBuildingKind> {
    insns: &'a [Insn],
    insn_source_locations: &'a [SourceLocation],
    labels: &'a BK::Labels,
    state_layout: &'a StateLayout<BK>,
}

struct InsnDebug<'a, BK: InsnsBuildingKind> {
    address: usize,
    source_location: Option<SourceLocation>,
    insn: &'a Insn,
    labels: Option<&'a Labels>,
    state_layout: &'a StateLayout<BK>,
}

impl<BK: InsnsBuildingKind> fmt::Debug for InsnDebug<'_, BK> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        if let Some(label_indexes) = self
            .labels
            .and_then(|labels| labels.address_to_label_indexes_map.get(&self.address))
        {
            for &label_index in label_indexes {
                writeln!(f, "L{label_index}:")?;
            }
        }
        if let Some(source_location) = self.source_location {
            writeln!(f, "// at: {source_location}")?;
        }
        self.insn.debug_fmt(f, self.labels, Some(self.state_layout))
    }
}

impl<'a, BK: InsnsBuildingKind> fmt::Debug for InsnsDebug<'a, BK> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let labels = BK::labels(&self.labels);
        let mut debug_list = f.debug_list();
        let mut last_source_location = None;
        for (address, (insn, &source_location)) in self
            .insns
            .iter()
            .zip(self.insn_source_locations)
            .enumerate()
        {
            debug_list.entry(&InsnDebug {
                address,
                source_location: if Some(source_location) != last_source_location {
                    Some(source_location)
                } else {
                    None
                },
                insn,
                labels,
                state_layout: self.state_layout,
            });
            last_source_location = Some(source_location);
        }
        debug_list.finish()
    }
}

impl<BK: InsnsBuildingKind> fmt::Debug for Insns<BK> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let Self {
            insns,
            insn_source_locations,
            labels,
            state_layout,
        } = self;
        f.debug_struct("Insns")
            .field("state_layout", state_layout)
            .field(
                "insns",
                &InsnsDebug::<BK> {
                    insns,
                    insn_source_locations,
                    labels,
                    state_layout,
                },
            )
            .finish_non_exhaustive()
    }
}

pub(crate) trait StatePartKind:
    Send + Sync + Ord + Hash + fmt::Debug + 'static + Copy + Default
{
    const NAME: &'static str;
    type DebugData: Send + Sync + Eq + Hash + fmt::Debug + 'static + Copy;
    type State: fmt::Debug + 'static + Clone;
    type BorrowedState<'a>: 'a;
    fn new_state(len: StatePartLen<Self>) -> Self::State;
    fn borrow_state<'a>(state: &'a mut Self::State) -> Self::BorrowedState<'a>;
    fn part_debug_data<BK: InsnsBuildingKind>(
        state_layout: &StateLayout<BK>,
        part_index: StatePartIndex<Self>,
    ) -> Option<&Self::DebugData>;
}

pub(crate) trait StatePartsValue {
    type Value<K: StatePartKind>;
}

macro_rules! impl_state_parts_traits {
    (
        struct $Struct:ident<$V:ident: $StatePartsValue:ident> {
            $(#[flatten]
            $flattened_field:ident: $flattened_field_ty:ty,
            $(#[field_in_flattened]
            $field_in_flattened:ident: $field_in_flattened_ty:ty,)*
            )?
            $($field:ident: $field_ty:ty,)*
        }
    ) => {
        impl<$V: $StatePartsValue> Copy for $Struct<$V>
        where
            $($flattened_field_ty: Copy,)?
            $($field_ty: Copy,)*
        {
        }

        impl<$V: $StatePartsValue> Clone for $Struct<$V>
        where
            $($flattened_field_ty: Clone,)?
            $($field_ty: Clone,)*
        {
            fn clone(&self) -> Self {
                Self {
                    $($flattened_field: self.$flattened_field.clone(),)?
                    $($field: self.$field.clone(),)*
                }
            }
        }

        impl<$V: $StatePartsValue> fmt::Debug for $Struct<$V>
        where
            $($($field_in_flattened_ty: fmt::Debug,)*)?
            $($field_ty: fmt::Debug,)*
        {
            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                f.debug_struct(stringify!($Struct))
                    $($(.field(stringify!($field_in_flattened), &self.$flattened_field.$field_in_flattened))*)?
                    $(.field(stringify!($field), &self.$field))*
                    .finish()
            }
        }

        impl<$V: $StatePartsValue> PartialEq for $Struct<$V>
        where
            $($flattened_field_ty: PartialEq,)?
            $($field_ty: PartialEq,)*
        {
            fn eq(&self, other: &Self) -> bool {
                true $(&& self.$flattened_field == other.$flattened_field)? $(&& self.$field == other.$field)*
            }
        }

        impl<$V: $StatePartsValue> Eq for $Struct<$V>
        where
            $($flattened_field_ty: Eq,)?
            $($field_ty: Eq,)*
        {
        }

        impl<$V: $StatePartsValue> Hash for $Struct<$V>
        where
            $($flattened_field_ty: Hash,)?
            $($field_ty: Hash,)*
        {
            fn hash<H: Hasher>(&self, h: &mut H) {
                $(self.$flattened_field.hash(h);)?
                $(self.$field.hash(h);)*
            }
        }

        impl<$V: $StatePartsValue> Default for $Struct<$V>
        where
            $($flattened_field_ty: Default,)?
            $($field_ty: Default,)*
        {
            fn default() -> Self {
                Self {
                    $($flattened_field: Default::default(),)?
                    $($field: Default::default(),)*
                }
            }
        }
    };
}

macro_rules! make_state_part_kinds {
    (
        $(
            #[state, field = $state_field:ident]
            impl $StateStatePartKind:ident for $StateKind:ident $state_impl_body:tt
        )*
        $(
            #[type, field = $type_field:ident]
            impl $TypeStatePartKind:ident for $TypeKind:ident $type_impl_body:tt
        )*
    ) => {
        $(
            #[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Clone, Copy, Default)]
            pub(crate) struct $StateKind;

            impl $StateStatePartKind for $StateKind $state_impl_body
        )*

        $(
            #[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Clone, Copy, Default)]
            pub(crate) struct $TypeKind;

            impl $TypeStatePartKind for $TypeKind $type_impl_body
        )*

        pub(crate) struct StateParts<V: StatePartsValue> {
            pub(crate) ty: TypeParts<V>,
            $(pub(crate) $state_field: V::Value<$StateKind>,)*
        }

        impl_state_parts_traits! {
            struct StateParts<V: StatePartsValue> {
                #[flatten]
                ty: TypeParts<V>,
                $(#[field_in_flattened]
                $type_field: V::Value<$TypeKind>,)*
                $($state_field: V::Value<$StateKind>,)*
            }
        }

        pub(crate) struct TypeParts<V: StatePartsValue> {
            $(pub(crate) $type_field: V::Value<$TypeKind>,)*
        }

        impl_state_parts_traits! {
            struct TypeParts<V: StatePartsValue> {
                $($type_field: V::Value<$TypeKind>,)*
            }
        }

        #[derive(Clone, PartialEq, Eq, Hash, Debug)]
        pub(crate) struct StateLayout<BK: InsnsBuildingKind> {
            pub(crate) ty: TypeLayout<BK>,
            $(pub(crate) $state_field: StatePartLayout<$StateKind, BK>,)*
        }

        impl Copy for StateLayout<InsnsBuildingDone> {}

        impl<BK: InsnsBuildingKind> StateLayout<BK> {
            pub(crate) fn len(&self) -> StateLen {
                StateLen {
                    ty: self.ty.len(),
                    $($state_field: self.$state_field.len(),)*
                }
            }
            pub(crate) fn is_empty(&self) -> bool {
                self.ty.is_empty() $(&& self.$state_field.is_empty())*
            }
            pub(crate) fn empty() -> Self {
                Self {
                    ty: TypeLayout::empty(),
                    $($state_field: StatePartLayout::empty(),)*
                }
            }
        }

        impl StateLayout<InsnsBuilding> {
            pub(crate) fn next_index(&self) -> StateIndex {
                StateIndex {
                    ty: self.ty.next_index(),
                    $($state_field: self.$state_field.next_index(),)*
                }
            }
            pub(crate) fn allocate<BK: InsnsBuildingKind>(
                &mut self,
                layout: &StateLayout<BK>,
            ) -> StateIndexRange {
                StateIndexRange {
                    ty: self.ty.allocate(&layout.ty),
                    $($state_field: self.$state_field.allocate(&layout.$state_field),)*
                }
            }
        }

        impl From<StateLayout<InsnsBuilding>> for StateLayout<InsnsBuildingDone> {
            fn from(v: StateLayout<InsnsBuilding>) -> Self {
                Self {
                    ty: v.ty.into(),
                    $($state_field: v.$state_field.into(),)*
                }
            }
        }

        #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
        pub(crate) struct StateIndexRange {
            pub(crate) ty: TypeIndexRange,
            $(pub(crate) $state_field: StatePartIndexRange<$StateKind>,)*
        }

        impl StateIndexRange {
            pub(crate) fn start(self) -> StateIndex {
                StateIndex {
                    ty: self.ty.start(),
                    $($state_field: self.$state_field.start(),)*
                }
            }
            pub(crate) fn len(self) -> StateLen {
                StateLen {
                    ty: self.ty.len(),
                    $($state_field: self.$state_field.len(),)*
                }
            }
            pub(crate) fn is_empty(self) -> bool {
                self.ty.is_empty() $(&& self.$state_field.is_empty())*
            }
        }

        #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
        pub(crate) struct StateLen {
            pub(crate) ty: TypeLen,
            $(pub(crate) $state_field: StatePartLen<$StateKind>,)*
        }

        #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
        pub(crate) struct StateIndex {
            pub(crate) ty: TypeIndex,
            $(pub(crate) $state_field: StatePartIndex<$StateKind>,)*
        }

        #[derive(Clone, PartialEq, Eq, Hash, Debug)]
        pub(crate) struct TypeLayout<BK: InsnsBuildingKind> {
            $(pub(crate) $type_field: StatePartLayout<$TypeKind, BK>,)*
        }

        impl Copy for TypeLayout<InsnsBuildingDone> {}

        impl<BK: InsnsBuildingKind> TypeLayout<BK> {
            pub(crate) fn len(&self) -> TypeLen {
                TypeLen {
                    $($type_field: self.$type_field.len(),)*
                }
            }
            pub(crate) fn is_empty(&self) -> bool {
                $(self.$type_field.is_empty())&&+
            }
            pub(crate) fn empty() -> Self {
                Self {
                    $($type_field: StatePartLayout::empty(),)*
                }
            }
        }

        impl TypeLayout<InsnsBuilding> {
            pub(crate) fn next_index(&self) -> TypeIndex {
                TypeIndex {
                    $($type_field: self.$type_field.next_index(),)*
                }
            }
            pub(crate) fn allocate<BK: InsnsBuildingKind>(
                &mut self,
                layout: &TypeLayout<BK>,
            ) -> TypeIndexRange {
                TypeIndexRange {
                    $($type_field: self.$type_field.allocate(&layout.$type_field),)*
                }
            }
        }

        impl From<TypeLayout<InsnsBuilding>> for TypeLayout<InsnsBuildingDone> {
            fn from(v: TypeLayout<InsnsBuilding>) -> Self {
                Self {
                    $($type_field: v.$type_field.into(),)*
                }
            }
        }

        #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
        pub(crate) struct TypeIndexRange {
            $(pub(crate) $type_field: StatePartIndexRange<$TypeKind>,)*
        }

        impl TypeIndexRange {
            pub(crate) fn new(start: TypeIndex, len: TypeLen) -> Self {
                Self {
                    $($type_field: StatePartIndexRange {
                        start: start.$type_field,
                        len: len.$type_field,
                    },)*
                }
            }
            pub(crate) fn start(self) -> TypeIndex {
                TypeIndex {
                    $($type_field: self.$type_field.start(),)*
                }
            }
            pub(crate) fn len(self) -> TypeLen {
                TypeLen {
                    $($type_field: self.$type_field.len(),)*
                }
            }
            pub(crate) fn is_empty(self) -> bool {
                $(self.$type_field.is_empty()) &&+
            }
            pub(crate) fn slice(self, index: TypeIndexRange) -> Self {
                Self {
                    $($type_field: self.$type_field.slice(index.$type_field),)*
                }
            }
            pub(crate) fn index_array(self, element_size: TypeLen, index: usize) -> Self {
                Self {
                    $($type_field: self.$type_field.index_array(element_size.$type_field, index),)*
                }
            }
            pub(crate) fn offset(self, offset: TypeIndex) -> Self {
                Self {
                    $($type_field: self.$type_field.offset(offset.$type_field),)*
                }
            }
        }

        #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
        pub(crate) struct TypeLen {
            $(pub(crate) $type_field: StatePartLen<$TypeKind>,)*
        }

        #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
        pub(crate) struct TypeIndex {
            $(pub(crate) $type_field: StatePartIndex<$TypeKind>,)*
        }

        impl TypeIndex {
            pub(crate) fn offset(self, offset: TypeIndex) -> Self {
                Self {
                    $($type_field: self.$type_field.offset(offset.$type_field),)*
                }
            }
        }

        #[derive(Debug)]
        pub(crate) struct State {
            pub(crate) insns: Interned<Insns<InsnsBuildingDone>>,
            pub(crate) pc: usize,
            $(pub(crate) $state_field: StatePart<$StateKind>,)*
            $(pub(crate) $type_field: StatePart<$TypeKind>,)*
        }

        impl State {
            pub(crate) fn new(insns: Interned<Insns<InsnsBuildingDone>>) -> Self {
                Self {
                    insns,
                    pc: 0,
                    $($state_field: StatePart::new(insns.state_layout.$state_field.len()),)*
                    $($type_field: StatePart::new(insns.state_layout.ty.$type_field.len()),)*
                }
            }
            pub(crate) fn borrow(&mut self) -> BorrowedState<'_> {
                BorrowedState {
                    orig_insns: self.insns,
                    insns: &self.insns.insns,
                    pc: self.pc,
                    orig_pc: &mut self.pc,
                    $($state_field: self.$state_field.borrow(),)*
                    $($type_field: self.$type_field.borrow(),)*
                }
            }
        }

        #[derive(Debug)]
        pub(crate) struct BorrowedState<'a> {
            pub(crate) orig_insns: Interned<Insns<InsnsBuildingDone>>,
            pub(crate) insns: &'a [Insn],
            pub(crate) orig_pc: &'a mut usize,
            pub(crate) pc: usize,
            $(pub(crate) $state_field: BorrowedStatePart<'a, $StateKind>,)*
            $(pub(crate) $type_field: BorrowedStatePart<'a, $TypeKind>,)*
        }

        impl Drop for BorrowedState<'_> {
            fn drop(&mut self) {
                *self.orig_pc = self.pc;
            }
        }

        #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, Default)]
        pub(crate) struct TypeArrayIndexes {
            $(pub(crate) $type_field: Interned<[StatePartArrayIndex<$TypeKind>]>,)*
        }

        impl TypeArrayIndexes {
            pub(crate) fn as_ref(&self) -> TypeArrayIndexesRef<'_> {
                TypeArrayIndexesRef {
                    $($type_field: &self.$type_field,)*
                }
            }
            #[must_use]
            pub(crate) fn join(self, next: TypeArrayIndex) -> TypeArrayIndexes {
                TypeArrayIndexes {
                    $($type_field: Interned::from_iter(self.$type_field.iter().copied().chain([next.$type_field])),)*
                }
            }
        }

        #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
        pub(crate) struct TypeArrayIndex {
            $(pub(crate) $type_field: StatePartArrayIndex<$TypeKind>,)*
        }

        impl TypeArrayIndex {
            pub(crate) fn from_parts(index: StatePartIndex<StatePartKindSmallSlots>, len: usize, stride: TypeLen) -> Self {
                Self {
                    $($type_field: StatePartArrayIndex {
                        index,
                        len,
                        stride: stride.$type_field,
                    },)*
                }
            }
            pub(crate) fn len(self) -> usize {
                let len = self.small_slots.len;
                $(assert_eq!(self.$type_field.len, len, "array length mismatch");)*
                len
            }
            pub(crate) fn index(self) -> StatePartIndex<StatePartKindSmallSlots> {
                let index = self.small_slots.index;
                $(assert_eq!(self.$type_field.index, index, "array index mismatch");)*
                index
            }
            pub(crate) fn is_empty(self) -> bool {
                self.len() == 0
            }
            pub(crate) fn stride(self) -> TypeLen {
                TypeLen {
                    $($type_field: self.$type_field.stride,)*
                }
            }
        }

        #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, Default)]
        pub(crate) struct TypeArrayIndexesRef<'a> {
            $(pub(crate) $type_field: &'a [StatePartArrayIndex<$TypeKind>],)*
        }

        impl<'a> TypeArrayIndexesRef<'a> {
            pub(crate) fn len(self) -> usize {
                let len = self.small_slots.len();
                $(assert_eq!(self.$type_field.len(), len, "indexes count mismatch");)*
                len
            }
            pub(crate) fn is_empty(self) -> bool {
                self.len() == 0
            }
            pub(crate) fn iter(self) -> impl Iterator<Item = TypeArrayIndex> + 'a {
                (0..self.len()).map(move |i| TypeArrayIndex {
                    $($type_field: self.$type_field[i],)*
                })
            }
            pub(crate) fn for_each_offset(
                self,
                mut f: impl FnMut(TypeIndex),
            ) {
                self.for_each_offset2(TypeIndex {
                    $($type_field: StatePartIndex {
                        value: 0,
                        _phantom: PhantomData,
                    },)*
                }, &mut f);
            }
            pub(crate) fn split_first(self) -> Option<(TypeArrayIndex, Self)> {
                $(let $type_field = self.$type_field.split_first()?;)*
                let next = TypeArrayIndex {
                    $($type_field: *$type_field.0,)*
                };
                let rest = TypeArrayIndexesRef {
                    $($type_field: $type_field.1,)*
                };
                Some((next, rest))
            }
            pub(crate) fn for_each_offset2(
                self,
                base_offset: TypeIndex,
                f: &mut (impl FnMut(TypeIndex) + ?Sized),
            ) {
                if let Some((next, rest)) = self.split_first() {
                    let stride = next.stride();
                    for index in 0..next.len().try_into().expect("array too big") {
                        let mut offset = TypeIndex {
                            $($type_field: StatePartIndex {
                                value: stride
                                    .$type_field
                                    .value
                                    .checked_mul(index)
                                    .expect("array too big"),
                                _phantom: PhantomData,
                            },)*
                        };
                        $(offset.$type_field.value =
                            base_offset
                                .$type_field
                                .value
                                .checked_add(offset.$type_field.value)
                                .expect("array too big");)*
                        rest.for_each_offset2(offset, f);
                    }
                } else {
                    $(assert!(self.$type_field.is_empty(), "indexes count mismatch");)*
                    f(base_offset);
                }
            }
        }

        #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
        pub(crate) struct TypeArrayIndexed {
            $(pub(crate) $type_field: StatePartArrayIndexed<$TypeKind>,)*
        }

        impl TypeArrayIndexed {
            pub(crate) fn from_parts(base: TypeIndex, indexes: TypeArrayIndexes) -> Self {
                Self {
                    $($type_field: StatePartArrayIndexed {
                        base: base.$type_field,
                        indexes: indexes.$type_field,
                    },)*
                }
            }
            pub(crate) fn base(self) -> TypeIndex {
                TypeIndex {
                    $($type_field: self.$type_field.base,)*
                }
            }
            pub(crate) fn indexes(self) -> TypeArrayIndexes {
                TypeArrayIndexes {
                    $($type_field: self.$type_field.indexes,)*
                }
            }
        }

        impl From<TypeIndex> for TypeArrayIndexed {
            fn from(value: TypeIndex) -> Self {
                TypeArrayIndexed {
                    $($type_field: value.$type_field.into(),)*
                }
            }
        }
    };
}

make_state_part_kinds! {
    /*#[state, field = small_stack]
    impl StatePartKind for StatePartKindSmallStack {
        const NAME: &'static str = "SmallStack";
        type DebugData = ();
        type State = Stack<SmallUInt>;
        type BorrowedState<'a> = BorrowedStack<'a, SmallUInt>;
        fn new_state(len: StatePartLen<Self>) -> Self::State {
            Stack::new(len.value.try_into().expect("state is too big"))
        }
        fn borrow_state<'a>(state: &'a mut Self::State) -> Self::BorrowedState<'a> {
            state.borrow()
        }
        fn part_debug_data<BK: InsnsBuildingKind>(
            state_layout: &StateLayout<BK>,
            part_index: StatePartIndex<Self>,
        ) -> Option<&Self::DebugData> {
            state_layout.small_stack.debug_data.get(part_index.as_usize())
        }
    }
    #[state, field = big_stack]
    impl StatePartKind for StatePartKindBigStack {
        const NAME: &'static str = "BigStack";
        type DebugData = ();
        type State = Stack<BigInt>;
        type BorrowedState<'a> = BorrowedStack<'a, BigInt>;
        fn new_state(len: StatePartLen<Self>) -> Self::State {
            Stack::new(len.value.try_into().expect("state is too big"))
        }
        fn borrow_state<'a>(state: &'a mut Self::State) -> Self::BorrowedState<'a> {
            state.borrow()
        }
        fn part_debug_data<BK: InsnsBuildingKind>(
            state_layout: &StateLayout<BK>,
            part_index: StatePartIndex<Self>,
        ) -> Option<&Self::DebugData> {
            state_layout.big_stack.debug_data.get(part_index.as_usize())
        }
    }*/
    #[type, field = small_slots]
    impl StatePartKind for StatePartKindSmallSlots {
        const NAME: &'static str = "SmallSlots";
        type DebugData = SlotDebugData;
        type State = Box<[SmallUInt]>;
        type BorrowedState<'a> = &'a mut [SmallUInt];
        fn new_state(len: StatePartLen<Self>) -> Self::State {
            vec![0; len.value.try_into().expect("state is too big")].into_boxed_slice()
        }
        fn borrow_state<'a>(state: &'a mut Self::State) -> Self::BorrowedState<'a> {
            state
        }
        fn part_debug_data<BK: InsnsBuildingKind>(
            state_layout: &StateLayout<BK>,
            part_index: StatePartIndex<Self>,
        ) -> Option<&Self::DebugData> {
            state_layout.ty.small_slots.debug_data.get(part_index.as_usize())
        }
    }
    #[type, field = big_slots]
    impl StatePartKind for StatePartKindBigSlots {
        const NAME: &'static str = "BigSlots";
        type DebugData = SlotDebugData;
        type State = Box<[BigInt]>;
        type BorrowedState<'a> = &'a mut [BigInt];
        fn new_state(len: StatePartLen<Self>) -> Self::State {
            std::iter::repeat_with(BigInt::default).take(len.value.try_into().expect("state is too big")).collect()
        }
        fn borrow_state<'a>(state: &'a mut Self::State) -> Self::BorrowedState<'a> {
            state
        }
        fn part_debug_data<BK: InsnsBuildingKind>(
            state_layout: &StateLayout<BK>,
            part_index: StatePartIndex<Self>,
        ) -> Option<&Self::DebugData> {
            state_layout.ty.big_slots.debug_data.get(part_index.as_usize())
        }
    }
}

impl TypeLen {
    pub(crate) fn only_small(self) -> Option<StatePartLen<StatePartKindSmallSlots>> {
        let Self {
            small_slots,
            big_slots:
                StatePartLen {
                    value: 0,
                    _phantom: _,
                },
        } = self
        else {
            return None;
        };
        Some(small_slots)
    }
}

#[derive(Debug, Clone)]
pub(crate) struct Stack<T> {
    storage: Box<[T]>,
    cur_len: usize,
}

impl<T> Stack<T> {
    pub(crate) fn new(len: usize) -> Self
    where
        T: Default,
    {
        Self {
            storage: std::iter::repeat_with(T::default).take(len).collect(),
            cur_len: 0,
        }
    }
    pub(crate) fn borrow(&mut self) -> BorrowedStack<'_, T> {
        BorrowedStack {
            storage: &mut self.storage,
            cur_len: self.cur_len,
            stack_cur_len: &mut self.cur_len,
        }
    }
    pub(crate) fn clear(&mut self) {
        self.cur_len = 0;
    }
}

#[derive(Debug)]
pub(crate) struct BorrowedStack<'a, T> {
    storage: &'a mut [T],
    cur_len: usize,
    stack_cur_len: &'a mut usize,
}

impl<'a, T> BorrowedStack<'a, T> {
    pub(crate) fn push(&mut self, value: T) {
        self.storage[self.cur_len] = value;
        self.cur_len += 1;
    }
    pub(crate) fn pop(&mut self) -> T
    where
        T: Default,
    {
        self.cur_len -= 1;
        std::mem::take(&mut self.storage[self.cur_len])
    }
}

impl<T> Drop for BorrowedStack<'_, T> {
    fn drop(&mut self) {
        *self.stack_cur_len = self.cur_len;
    }
}

#[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
pub(crate) struct SlotDebugData {
    pub(crate) name: Interned<str>,
    pub(crate) ty: CanonicalType,
}

impl SlotDebugData {
    pub(crate) fn with_prefixed_debug_names(&self, prefix: &str) -> Self {
        let mut name = String::with_capacity(self.name.len() + prefix.len());
        name.push_str(prefix);
        name.push_str(&self.name);
        Self {
            name: Intern::intern_owned(name),
            ty: self.ty,
        }
    }
    pub(crate) fn with_anonymized_debug_info(&self) -> Self {
        Self {
            name: Interned::default(),
            ty: self.ty,
        }
    }
}

impl<K: StatePartKind<DebugData = SlotDebugData>, BK: InsnsBuildingKind> StatePartLayout<K, BK> {
    pub(crate) fn with_prefixed_debug_names(&self, prefix: &str) -> Self {
        Self {
            debug_data: self
                .debug_data
                .iter()
                .map(|v| v.with_prefixed_debug_names(prefix))
                .collect(),
            _phantom: PhantomData,
        }
    }
    pub(crate) fn with_anonymized_debug_info(&self) -> Self {
        Self {
            debug_data: self
                .debug_data
                .iter()
                .map(|v| v.with_anonymized_debug_info())
                .collect(),
            _phantom: PhantomData,
        }
    }
}

impl<BK: InsnsBuildingKind> TypeLayout<BK> {
    pub(crate) fn with_prefixed_debug_names(&self, prefix: &str) -> Self {
        Self {
            small_slots: self.small_slots.with_prefixed_debug_names(prefix),
            big_slots: self.big_slots.with_prefixed_debug_names(prefix),
        }
    }
    pub(crate) fn with_anonymized_debug_info(&self) -> Self {
        Self {
            small_slots: self.small_slots.with_anonymized_debug_info(),
            big_slots: self.big_slots.with_anonymized_debug_info(),
        }
    }
}

#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
pub(crate) struct StatePartArrayIndex<K: StatePartKind> {
    pub(crate) index: StatePartIndex<StatePartKindSmallSlots>,
    pub(crate) len: usize,
    pub(crate) stride: StatePartLen<K>,
}

#[derive(Copy, Clone, PartialEq, Eq, Hash)]
pub(crate) struct StatePartArrayIndexed<K: StatePartKind> {
    pub(crate) base: StatePartIndex<K>,
    pub(crate) indexes: Interned<[StatePartArrayIndex<K>]>,
}

impl<K: StatePartKind> StatePartArrayIndexed<K> {
    pub(crate) fn debug_fmt<BK: InsnsBuildingKind>(
        &self,
        f: &mut fmt::Formatter<'_>,
        before_debug_info_text: &str,
        comment_start: &str,
        comment_end: &str,
        state_layout: Option<&StateLayout<BK>>,
    ) -> fmt::Result {
        if let Some(state_layout) = state_layout {
            let Self { base, indexes } = *self;
            if indexes.is_empty() {
                base.debug_fmt(
                    f,
                    before_debug_info_text,
                    comment_start,
                    comment_end,
                    Some(state_layout),
                )
            } else {
                base.debug_fmt(f, "", " /* ", " */ ", Some(state_layout))?;
                for StatePartArrayIndex { index, len, stride } in indexes {
                    f.write_str("[")?;
                    index.debug_fmt(f, "", " /* ", " */ ", Some(state_layout))?;
                    write!(f, ", len={len}, stride={}]", stride.value)?;
                }
                f.write_str(before_debug_info_text)
            }
        } else {
            let Self { base, indexes } = self;
            f.debug_struct("StatePartArrayIndexed")
                .field("base", base)
                .field("indexes", indexes)
                .finish()?;
            f.write_str(before_debug_info_text)
        }
    }
}

impl<K: StatePartKind + fmt::Debug> fmt::Debug for StatePartArrayIndexed<K> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.debug_fmt::<InsnsBuildingDone>(f, "", "", "", None)
    }
}

impl<K: StatePartKind> From<StatePartIndex<K>> for StatePartArrayIndexed<K> {
    fn from(base: StatePartIndex<K>) -> Self {
        Self {
            base,
            indexes: Interned::default(),
        }
    }
}

impl<K: StatePartKind> StatePartArrayIndexed<K> {
    pub(crate) fn for_each_target2(
        base: StatePartIndex<K>,
        indexes: &[StatePartArrayIndex<K>],
        f: &mut (impl FnMut(StatePartIndex<K>) + ?Sized),
    ) {
        if let [next, rest @ ..] = indexes {
            for i in 0..next.len.try_into().expect("array too big") {
                Self::for_each_target2(
                    StatePartIndex {
                        value: base
                            .value
                            .checked_add(next.stride.value.checked_mul(i).expect("array too big"))
                            .expect("array too big"),
                        _phantom: PhantomData,
                    },
                    rest,
                    f,
                );
            }
        } else {
            f(base);
        }
    }
    pub(crate) fn for_each_target(self, mut f: impl FnMut(StatePartIndex<K>)) {
        Self::for_each_target2(self.base, &self.indexes, &mut f);
    }
}

#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub(crate) struct StatePartIndex<K: StatePartKind> {
    pub(crate) value: u32,
    pub(crate) _phantom: PhantomData<K>,
}

impl<K: StatePartKind> StatePartIndex<K> {
    pub(crate) fn as_usize(self) -> usize {
        self.value.try_into().expect("index too big")
    }
    pub(crate) fn offset(self, offset: StatePartIndex<K>) -> Self {
        Self {
            value: self
                .value
                .checked_add(offset.value)
                .expect("offset too big"),
            _phantom: PhantomData,
        }
    }
    pub(crate) fn debug_fmt<BK: InsnsBuildingKind>(
        &self,
        f: &mut fmt::Formatter<'_>,
        before_debug_info_text: &str,
        comment_start: &str,
        comment_end: &str,
        state_layout: Option<&StateLayout<BK>>,
    ) -> fmt::Result {
        write!(f, "StatePartIndex<{}>({})", K::NAME, self.value)?;
        f.write_str(before_debug_info_text)?;
        if let Some(state_layout) = state_layout {
            if let Some(debug_data) = K::part_debug_data(state_layout, *self) {
                write!(f, "{comment_start}{debug_data:?}{comment_end}")?;
            }
        }
        Ok(())
    }
}

impl<K: StatePartKind> fmt::Debug for StatePartIndex<K> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.debug_fmt::<InsnsBuildingDone>(f, "", "", "", None)
    }
}

#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub(crate) struct StatePartLen<K: StatePartKind> {
    pub(crate) value: u32,
    pub(crate) _phantom: PhantomData<K>,
}

impl<K: StatePartKind> StatePartLen<K> {
    pub(crate) const fn new(value: u32) -> Self {
        Self {
            value,
            _phantom: PhantomData,
        }
    }
}

impl<K: StatePartKind> fmt::Debug for StatePartLen<K> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "StatePartLen<{}>({})", K::NAME, self.value)
    }
}

#[derive(Clone, PartialEq, Eq, Hash)]
pub(crate) struct StatePartLayout<K: StatePartKind, BK: InsnsBuildingKind> {
    pub(crate) debug_data: BK::Vec<K::DebugData>,
    pub(crate) _phantom: PhantomData<K>,
}

impl<K: StatePartKind> Copy for StatePartLayout<K, InsnsBuildingDone> {}

impl<K: StatePartKind, BK: InsnsBuildingKind> StatePartLayout<K, BK> {
    pub(crate) fn len(&self) -> StatePartLen<K> {
        StatePartLen::new(
            self.debug_data
                .len()
                .try_into()
                .expect("state part allocation layout is too big"),
        )
    }
    pub(crate) fn is_empty(&self) -> bool {
        self.debug_data.is_empty()
    }
    pub(crate) fn empty() -> Self {
        Self {
            debug_data: Default::default(),
            _phantom: PhantomData,
        }
    }
}

impl<K: StatePartKind> From<StatePartLayout<K, InsnsBuilding>>
    for StatePartLayout<K, InsnsBuildingDone>
{
    fn from(value: StatePartLayout<K, InsnsBuilding>) -> Self {
        Self {
            debug_data: Intern::intern_owned(value.debug_data),
            _phantom: PhantomData,
        }
    }
}

impl<K: StatePartKind> StatePartLayout<K, InsnsBuilding> {
    pub(crate) fn scalar(debug_data: K::DebugData) -> Self {
        Self {
            debug_data: vec![debug_data],
            _phantom: PhantomData,
        }
    }
    pub(crate) fn next_index(&self) -> StatePartIndex<K> {
        StatePartIndex {
            value: self.len().value,
            _phantom: PhantomData,
        }
    }
    pub(crate) fn allocate<BK: InsnsBuildingKind>(
        &mut self,
        layout: &StatePartLayout<K, BK>,
    ) -> StatePartIndexRange<K> {
        let start = self.next_index();
        let len = layout.len();
        let Self {
            debug_data,
            _phantom: _,
        } = self;
        debug_data.extend_from_slice(&layout.debug_data);
        StatePartIndexRange { start, len }
    }
}

impl<K: StatePartKind, BK: InsnsBuildingKind> fmt::Debug for StatePartLayout<K, BK> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let Self {
            debug_data,
            _phantom: _,
        } = self;
        write!(f, "StatePartAllocationLayout<{}>", K::NAME)?;
        f.debug_struct("")
            .field("len", &debug_data.len())
            .field("debug_data", debug_data)
            .finish_non_exhaustive()
    }
}

#[derive(Copy, Clone, PartialEq, Eq, Hash)]
pub(crate) struct StatePartIndexRange<K: StatePartKind> {
    pub(crate) start: StatePartIndex<K>,
    pub(crate) len: StatePartLen<K>,
}

impl<K: StatePartKind> StatePartIndexRange<K> {
    pub(crate) fn start(self) -> StatePartIndex<K> {
        self.start
    }
    pub(crate) fn end(self) -> StatePartIndex<K> {
        StatePartIndex {
            value: self
                .start
                .value
                .checked_add(self.len.value)
                .expect("state part allocation layout is too big"),
            _phantom: PhantomData,
        }
    }
    pub(crate) fn len(self) -> StatePartLen<K> {
        self.len
    }
    pub(crate) fn is_empty(self) -> bool {
        self.len.value == 0
    }
    pub(crate) fn iter(self) -> impl Iterator<Item = StatePartIndex<K>> {
        (self.start.value..self.end().value).map(|value| StatePartIndex {
            value,
            _phantom: PhantomData,
        })
    }
    pub(crate) fn offset(self, offset: StatePartIndex<K>) -> Self {
        self.end().offset(offset); // check for overflow
        Self {
            start: self.start.offset(offset),
            len: self.len,
        }
    }
    pub(crate) fn slice(self, index: StatePartIndexRange<K>) -> Self {
        assert!(index.end().value <= self.len.value, "index out of range");
        Self {
            start: StatePartIndex {
                value: self.start.value + index.start.value,
                _phantom: PhantomData,
            },
            len: index.len,
        }
    }
    pub(crate) fn index_array(self, element_size: StatePartLen<K>, index: usize) -> Self {
        if element_size.value == 0 {
            assert_eq!(
                self.len.value, 0,
                "array with zero-sized element must also be zero-sized",
            );
            return self;
        }
        assert!(
            self.len.value % element_size.value == 0,
            "array's size must be a multiple of its element size",
        );
        self.slice(StatePartIndexRange {
            start: StatePartIndex {
                value: index
                    .try_into()
                    .ok()
                    .and_then(|index| element_size.value.checked_mul(index))
                    .expect("index out of range"),
                _phantom: PhantomData,
            },
            len: element_size,
        })
    }
}

impl<K: StatePartKind> fmt::Debug for StatePartIndexRange<K> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            f,
            "StatePartIndexRange<{}> {{ start: {}, len: {} }}",
            K::NAME,
            self.start.value,
            self.len.value
        )
    }
}

#[derive(Clone, PartialEq, Eq, Hash, Debug)]
pub(crate) struct StatePart<K: StatePartKind> {
    pub(crate) value: K::State,
}

impl<K: StatePartKind> StatePart<K> {
    pub(crate) fn new(len: StatePartLen<K>) -> Self {
        Self {
            value: K::new_state(len),
        }
    }
    pub(crate) fn borrow<'a>(&'a mut self) -> BorrowedStatePart<'a, K> {
        BorrowedStatePart {
            value: K::borrow_state(&mut self.value),
        }
    }
}

#[derive(Clone, PartialEq, Eq, Hash, Debug)]
pub(crate) struct BorrowedStatePart<'a, K: StatePartKind> {
    pub(crate) value: K::BorrowedState<'a>,
}

impl<
        'a,
        K: StatePartKind<
            BorrowedState<'a>: DerefMut<Target: IndexMut<usize, Output = T> + BorrowMut<[T]>>,
        >,
        T,
    > BorrowedStatePart<'a, K>
{
    pub(crate) fn get_many_mut<const N: usize>(
        &mut self,
        indexes: [StatePartIndex<K>; N],
    ) -> [&mut T; N] {
        get_many_mut(
            (*self.value).borrow_mut(),
            indexes.map(|v| v.value as usize),
        )
    }
}

impl<'a, K: StatePartKind<BorrowedState<'a>: Deref<Target: Index<usize, Output = T>>>, T>
    Index<StatePartIndex<K>> for BorrowedStatePart<'a, K>
{
    type Output = T;
    fn index(&self, index: StatePartIndex<K>) -> &Self::Output {
        &self.value[index.value as usize]
    }
}

impl<'a, K: StatePartKind<BorrowedState<'a>: DerefMut<Target: IndexMut<usize, Output = T>>>, T>
    IndexMut<StatePartIndex<K>> for BorrowedStatePart<'a, K>
{
    fn index_mut(&mut self, index: StatePartIndex<K>) -> &mut Self::Output {
        &mut self.value[index.value as usize]
    }
}

impl<'a, K: StatePartKind<BorrowedState<'a> = BorrowedStack<'a, T>>, T: 'a>
    BorrowedStatePart<'a, K>
{
    pub(crate) fn push(&mut self, value: T) {
        self.value.push(value)
    }
    pub(crate) fn pop(&mut self) -> T
    where
        T: Default,
    {
        self.value.pop()
    }
}

#[derive(PartialEq, Eq, Hash, Clone)]
pub(crate) struct StatePartIndexMap<K: StatePartKind, V> {
    pub(crate) map: VecMap<V>,
    _phantom: PhantomData<K>,
}

impl<K: StatePartKind, V: fmt::Debug> fmt::Debug for StatePartIndexMap<K, V> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_map().entries(self.iter()).finish()
    }
}

impl<K: StatePartKind, V> Extend<(StatePartIndex<K>, V)> for StatePartIndexMap<K, V> {
    fn extend<T: IntoIterator<Item = (StatePartIndex<K>, V)>>(&mut self, iter: T) {
        self.map
            .extend(iter.into_iter().map(|(k, v)| (k.as_usize(), v)));
    }
}

impl<K: StatePartKind, V> StatePartIndexMap<K, V> {
    pub(crate) fn new() -> Self {
        Self {
            map: VecMap::new(),
            _phantom: PhantomData,
        }
    }
    pub(crate) fn get(&self, key: StatePartIndex<K>) -> Option<&V> {
        self.map.get(key.as_usize())
    }
    pub(crate) fn get_mut(&mut self, key: StatePartIndex<K>) -> Option<&mut V> {
        self.map.get_mut(key.as_usize())
    }
    pub(crate) fn keys(&self) -> impl Iterator<Item = StatePartIndex<K>> + '_ {
        self.map.keys().map(|k| StatePartIndex {
            value: k as u32,
            _phantom: PhantomData,
        })
    }
    pub(crate) fn values(&self) -> vec_map::Values<'_, V> {
        self.map.values()
    }
    pub(crate) fn values_mut(&mut self) -> vec_map::ValuesMut<'_, V> {
        self.map.values_mut()
    }
    pub(crate) fn iter(&self) -> impl Iterator<Item = (StatePartIndex<K>, &V)> + '_ {
        self.map.iter().map(|(k, v)| {
            (
                StatePartIndex {
                    value: k as u32,
                    _phantom: PhantomData,
                },
                v,
            )
        })
    }
    pub(crate) fn iter_mut(&mut self) -> impl Iterator<Item = (StatePartIndex<K>, &mut V)> + '_ {
        self.map.iter_mut().map(|(k, v)| {
            (
                StatePartIndex {
                    value: k as u32,
                    _phantom: PhantomData,
                },
                v,
            )
        })
    }
    pub(crate) fn len(&self) -> usize {
        self.map.len()
    }
    pub(crate) fn is_empty(&self) -> bool {
        self.map.is_empty()
    }
    pub(crate) fn insert(&mut self, key: StatePartIndex<K>, value: V) -> Option<V> {
        self.map.insert(key.as_usize(), value)
    }
    pub(crate) fn remove(&mut self, key: StatePartIndex<K>) -> Option<V> {
        self.map.remove(key.as_usize())
    }
    pub(crate) fn entry(&mut self, key: StatePartIndex<K>) -> StatePartIndexMapEntry<'_, K, V> {
        match self.map.entry(key.as_usize()) {
            vec_map::Entry::Vacant(v) => {
                StatePartIndexMapEntry::Vacant(StatePartIndexMapVacantEntry(v, PhantomData))
            }
            vec_map::Entry::Occupied(v) => {
                StatePartIndexMapEntry::Occupied(StatePartIndexMapOccupiedEntry(v, PhantomData))
            }
        }
    }
}

impl<K: StatePartKind, V> Default for StatePartIndexMap<K, V> {
    fn default() -> Self {
        Self::new()
    }
}

impl<K: StatePartKind, V> Index<StatePartIndex<K>> for StatePartIndexMap<K, V> {
    type Output = V;

    fn index(&self, index: StatePartIndex<K>) -> &Self::Output {
        &self.map[index.as_usize()]
    }
}

impl<K: StatePartKind, V> IndexMut<StatePartIndex<K>> for StatePartIndexMap<K, V> {
    fn index_mut(&mut self, index: StatePartIndex<K>) -> &mut Self::Output {
        &mut self.map[index.as_usize()]
    }
}

pub(crate) struct StatePartIndexMapVacantEntry<'a, K: StatePartKind, V>(
    vec_map::VacantEntry<'a, V>,
    PhantomData<K>,
);

pub(crate) struct StatePartIndexMapOccupiedEntry<'a, K: StatePartKind, V>(
    vec_map::OccupiedEntry<'a, V>,
    PhantomData<K>,
);

pub(crate) enum StatePartIndexMapEntry<'a, K: StatePartKind, V> {
    Vacant(StatePartIndexMapVacantEntry<'a, K, V>),
    Occupied(StatePartIndexMapOccupiedEntry<'a, K, V>),
}

impl<'a, K: StatePartKind, V> StatePartIndexMapEntry<'a, K, V> {
    pub(crate) fn or_insert(self, default: V) -> &'a mut V {
        match self {
            StatePartIndexMapEntry::Vacant(v) => v.0.insert(default),
            StatePartIndexMapEntry::Occupied(v) => v.0.into_mut(),
        }
    }
    pub(crate) fn or_insert_with(self, f: impl FnOnce() -> V) -> &'a mut V {
        match self {
            StatePartIndexMapEntry::Vacant(v) => v.0.insert(f()),
            StatePartIndexMapEntry::Occupied(v) => v.0.into_mut(),
        }
    }
}

impl Insns<InsnsBuilding> {
    pub(crate) fn new() -> Self {
        Self {
            insns: Vec::new(),
            insn_source_locations: Vec::new(),
            labels: Labels::default(),
            state_layout: StateLayout::empty(),
        }
    }
    pub(crate) fn last_insn_pc(&self) -> usize {
        self.insns
            .len()
            .checked_sub(1)
            .expect("no last instruction")
    }
    pub(crate) fn next_insn_pc(&self) -> usize {
        self.insns.len()
    }
    pub(crate) fn push(&mut self, insn: Insn, source_location: SourceLocation) {
        self.insns.push(insn);
        self.insn_source_locations.push(source_location);
    }
    pub(crate) fn allocate_variable<BK: InsnsBuildingKind>(
        &mut self,
        layout: &TypeLayout<BK>,
    ) -> TypeIndexRange {
        self.state_layout.ty.allocate(layout)
    }
    pub(crate) fn new_label(&mut self) -> usize {
        let retval = self.labels.labels.len();
        self.labels.labels.push(Label { address: None });
        retval
    }
    #[track_caller]
    pub(crate) fn define_label_at_next_insn(&mut self, label_index: usize) {
        let address = self.next_insn_pc();
        let label = &mut self.labels.labels[label_index];
        assert!(label.address.is_none(), "label already defined");
        label.address = Some(address);
        self.labels
            .address_to_label_indexes_map
            .entry(address)
            .or_default()
            .push(label_index);
    }
}

impl From<Insns<InsnsBuilding>> for Insns<InsnsBuildingDone> {
    fn from(input: Insns<InsnsBuilding>) -> Self {
        let Insns {
            mut insns,
            insn_source_locations,
            labels,
            state_layout,
        } = input;
        for insn in &mut insns {
            for field in insn.fields_mut() {
                match field.kind {
                    InsnFieldKind::BranchTarget => match field.ty {
                        InsnFieldType::USize(value) => {
                            *value = labels.labels[*value]
                                .address
                                .expect("label address not set");
                        }
                        InsnFieldType::SmallSlot(_)
                        | InsnFieldType::BigSlot(_)
                        | InsnFieldType::SmallSlotArrayIndexed(_)
                        | InsnFieldType::BigSlotArrayIndexed(_)
                        | InsnFieldType::SmallUInt(_)
                        | InsnFieldType::SmallSInt(_)
                        | InsnFieldType::InternedBigInt(_)
                        | InsnFieldType::U8(_)
                        | InsnFieldType::Empty(_) => {
                            unreachable!()
                        }
                    },
                    InsnFieldKind::Input | InsnFieldKind::Output | InsnFieldKind::Immediate => {}
                }
            }
        }
        Insns {
            insns: Intern::intern_owned(insns),
            insn_source_locations: Intern::intern_owned(insn_source_locations),
            labels: (),
            state_layout: state_layout.into(),
        }
    }
}

impl State {
    pub(crate) fn setup_call(&mut self, entry_pc: usize) {
        let Self {
            insns: _,
            pc,
            small_slots: _,
            big_slots: _,
        } = self;
        *pc = entry_pc;
    }
}

impl BorrowedState<'_> {
    fn eval_array_indexed<K: StatePartKind>(
        &self,
        array_indexed: StatePartArrayIndexed<K>,
    ) -> Option<StatePartIndex<K>> {
        let StatePartArrayIndexed {
            base: mut retval,
            indexes,
        } = array_indexed;
        for StatePartArrayIndex { index, len, stride } in indexes {
            let index = self.small_slots[index];
            if index >= len as SmallUInt {
                return None;
            }
            retval.value += stride.value * index as u32;
        }
        Some(retval)
    }
}

fn bigint_pow2(width: usize) -> Interned<BigInt> {
    #[derive(Copy, Clone, PartialEq, Eq, Hash)]
    struct MyMemoize;
    impl Memoize for MyMemoize {
        type Input = usize;
        type InputOwned = usize;
        type Output = Interned<BigInt>;

        fn inner(self, input: &Self::Input) -> Self::Output {
            (BigInt::one() << *input).intern_sized()
        }
    }
    MyMemoize.get(&width)
}

fn bigint_mask(width: usize) -> Interned<BigInt> {
    #[derive(Copy, Clone, PartialEq, Eq, Hash)]
    struct MyMemoize;
    impl Memoize for MyMemoize {
        type Input = usize;
        type InputOwned = usize;
        type Output = Interned<BigInt>;

        fn inner(self, input: &Self::Input) -> Self::Output {
            ((BigInt::one() << *input) - BigInt::one()).intern_sized()
        }
    }
    MyMemoize.get(&width)
}

fn bigint_not_mask(width: usize) -> Interned<BigInt> {
    #[derive(Copy, Clone, PartialEq, Eq, Hash)]
    struct MyMemoize;
    impl Memoize for MyMemoize {
        type Input = usize;
        type InputOwned = usize;
        type Output = Interned<BigInt>;

        fn inner(self, input: &Self::Input) -> Self::Output {
            (-BigInt::one() << *input).intern_sized()
        }
    }
    MyMemoize.get(&width)
}

fn cast_bigint_to_sint(src: &BigInt, dest_width: usize) -> BigInt {
    if dest_width == 0 {
        BigInt::ZERO
    } else if src.bit((dest_width - 1) as u64) {
        src | &*bigint_not_mask(dest_width)
    } else {
        src & &*bigint_mask(dest_width)
    }
}

fn cast_bigint_to_uint(src: &BigInt, dest_width: usize) -> BigInt {
    src & &*bigint_mask(dest_width)
}

impl_insns! {
    #[insn = Insn, next_macro = next, branch_macro = branch]
    pub(crate) fn State::run(&mut self) -> () {
        #[state]
        let mut state = self.borrow();
        setup! {}
        main_loop!();
        cleanup! {}
    }
    Copy {
        #[kind = Output]
        dest: StatePartIndex<StatePartKindBigSlots>,
        #[kind = Input]
        src: StatePartIndex<StatePartKindBigSlots>,
    } => {
        if dest != src {
            let [dest, src] = state.big_slots.get_many_mut([dest, src]);
            dest.clone_from(src);
        }
        next!();
    }
    CopySmall {
        #[kind = Output]
        dest: StatePartIndex<StatePartKindSmallSlots>,
        #[kind = Input]
        src: StatePartIndex<StatePartKindSmallSlots>,
    } => {
        state.small_slots[dest] = state.small_slots[src];
        next!();
    }
    ReadIndexed {
        #[kind = Output]
        dest: StatePartIndex<StatePartKindBigSlots>,
        #[kind = Input]
        src: StatePartArrayIndexed<StatePartKindBigSlots>,
    } => {
        if let Some(src) = state.eval_array_indexed(src) {
            if dest != src {
                let [dest, src] = state.big_slots.get_many_mut([dest, src]);
                dest.clone_from(src);
            }
        } else {
            state.big_slots[dest] = BigInt::ZERO;
        }
        next!();
    }
    ReadSmallIndexed {
        #[kind = Output]
        dest: StatePartIndex<StatePartKindSmallSlots>,
        #[kind = Input]
        src: StatePartArrayIndexed<StatePartKindSmallSlots>,
    } => {
        if let Some(src) = state.eval_array_indexed(src) {
            state.small_slots[dest] = state.small_slots[src];
        } else {
            state.small_slots[dest] = 0;
        }
        next!();
    }
    WriteIndexed {
        #[kind = Output]
        dest: StatePartArrayIndexed<StatePartKindBigSlots>,
        #[kind = Input]
        src: StatePartIndex<StatePartKindBigSlots>,
    } => {
        if let Some(dest) = state.eval_array_indexed(dest) {
            if dest != src {
                let [dest, src] = state.big_slots.get_many_mut([dest, src]);
                dest.clone_from(src);
            }
        }
        next!();
    }
    WriteSmallIndexed {
        #[kind = Output]
        dest: StatePartArrayIndexed<StatePartKindSmallSlots>,
        #[kind = Input]
        src: StatePartIndex<StatePartKindSmallSlots>,
    } => {
        if let Some(dest) = state.eval_array_indexed(dest) {
            state.small_slots[dest] = state.small_slots[src];
        }
        next!();
    }
    CastBigToArrayIndex {
        #[kind = Output]
        dest: StatePartIndex<StatePartKindSmallSlots>,
        #[kind = Input]
        src: StatePartIndex<StatePartKindBigSlots>,
    } => {
        let src = &state.big_slots[src];
        let value = src.try_into().unwrap_or(SmallUInt::MAX);
        state.small_slots[dest] = value;
        next!();
    }
    CastToSInt {
        #[kind = Output]
        dest: StatePartIndex<StatePartKindBigSlots>,
        #[kind = Input]
        src: StatePartIndex<StatePartKindBigSlots>,
        #[kind = Immediate]
        dest_width: usize,
    } => {
        let value = cast_bigint_to_sint(&state.big_slots[src], dest_width);
        state.big_slots[dest] = value;
        next!();
    }
    CastToUInt {
        #[kind = Output]
        dest: StatePartIndex<StatePartKindBigSlots>,
        #[kind = Input]
        src: StatePartIndex<StatePartKindBigSlots>,
        #[kind = Immediate]
        dest_width: usize,
    } => {
        let value = cast_bigint_to_uint(&state.big_slots[src], dest_width);
        state.big_slots[dest] = value;
        next!();
    }
    And {
        #[kind = Output]
        dest: StatePartIndex<StatePartKindBigSlots>,
        #[kind = Input]
        lhs: StatePartIndex<StatePartKindBigSlots>,
        #[kind = Input]
        rhs: StatePartIndex<StatePartKindBigSlots>,
    } => {
        let value = &state.big_slots[lhs] & &state.big_slots[rhs];
        state.big_slots[dest] = value;
        next!();
    }
    Or {
        #[kind = Output]
        dest: StatePartIndex<StatePartKindBigSlots>,
        #[kind = Input]
        lhs: StatePartIndex<StatePartKindBigSlots>,
        #[kind = Input]
        rhs: StatePartIndex<StatePartKindBigSlots>,
    } => {
        let value = &state.big_slots[lhs] | &state.big_slots[rhs];
        state.big_slots[dest] = value;
        next!();
    }
    Xor {
        #[kind = Output]
        dest: StatePartIndex<StatePartKindBigSlots>,
        #[kind = Input]
        lhs: StatePartIndex<StatePartKindBigSlots>,
        #[kind = Input]
        rhs: StatePartIndex<StatePartKindBigSlots>,
    } => {
        let value = &state.big_slots[lhs] ^ &state.big_slots[rhs];
        state.big_slots[dest] = value;
        next!();
    }
    NotS {
        #[kind = Output]
        dest: StatePartIndex<StatePartKindBigSlots>,
        #[kind = Input]
        src: StatePartIndex<StatePartKindBigSlots>,
    } => {
        let value = !&state.big_slots[src];
        state.big_slots[dest] = value;
        next!();
    }
    NotU {
        #[kind = Output]
        dest: StatePartIndex<StatePartKindBigSlots>,
        #[kind = Input]
        src: StatePartIndex<StatePartKindBigSlots>,
        #[kind = Immediate]
        width: usize,
    } => {
        let value = &state.big_slots[src] ^ &*bigint_mask(width);
        state.big_slots[dest] = value;
        next!();
    }
    Neg {
        #[kind = Output]
        dest: StatePartIndex<StatePartKindBigSlots>,
        #[kind = Input]
        src: StatePartIndex<StatePartKindBigSlots>,
    } => {
        let value = -&state.big_slots[src];
        state.big_slots[dest] = value;
        next!();
    }
    Add {
        #[kind = Output]
        dest: StatePartIndex<StatePartKindBigSlots>,
        #[kind = Input]
        lhs: StatePartIndex<StatePartKindBigSlots>,
        #[kind = Input]
        rhs: StatePartIndex<StatePartKindBigSlots>,
    } => {
        let value = &state.big_slots[lhs] + &state.big_slots[rhs];
        state.big_slots[dest] = value;
        next!();
    }
    SubS {
        #[kind = Output]
        dest: StatePartIndex<StatePartKindBigSlots>,
        #[kind = Input]
        lhs: StatePartIndex<StatePartKindBigSlots>,
        #[kind = Input]
        rhs: StatePartIndex<StatePartKindBigSlots>,
    } => {
        let value = &state.big_slots[lhs] - &state.big_slots[rhs];
        state.big_slots[dest] = value;
        next!();
    }
    SubU {
        #[kind = Output]
        dest: StatePartIndex<StatePartKindBigSlots>,
        #[kind = Input]
        lhs: StatePartIndex<StatePartKindBigSlots>,
        #[kind = Input]
        rhs: StatePartIndex<StatePartKindBigSlots>,
        #[kind = Immediate]
        dest_width: usize,
    } => {
        let mut value = &state.big_slots[lhs] - &state.big_slots[rhs];
        value &= &*bigint_mask(dest_width);
        state.big_slots[dest] = value;
        next!();
    }
    Mul {
        #[kind = Output]
        dest: StatePartIndex<StatePartKindBigSlots>,
        #[kind = Input]
        lhs: StatePartIndex<StatePartKindBigSlots>,
        #[kind = Input]
        rhs: StatePartIndex<StatePartKindBigSlots>,
    } => {
        let value = &state.big_slots[lhs] * &state.big_slots[rhs];
        state.big_slots[dest] = value;
        next!();
    }
    Div {
        #[kind = Output]
        dest: StatePartIndex<StatePartKindBigSlots>,
        #[kind = Input]
        lhs: StatePartIndex<StatePartKindBigSlots>,
        #[kind = Input]
        rhs: StatePartIndex<StatePartKindBigSlots>,
    } => {
        let value = state.big_slots[lhs].checked_div(&state.big_slots[rhs]).unwrap_or(BigInt::ZERO);
        state.big_slots[dest] = value;
        next!();
    }
    Rem {
        #[kind = Output]
        dest: StatePartIndex<StatePartKindBigSlots>,
        #[kind = Input]
        lhs: StatePartIndex<StatePartKindBigSlots>,
        #[kind = Input]
        rhs: StatePartIndex<StatePartKindBigSlots>,
    } => {
        // no checked_rem?!
        let value = if state.big_slots[rhs].is_zero() {
            BigInt::ZERO
        } else {
            &state.big_slots[lhs] % &state.big_slots[rhs]
        };
        state.big_slots[dest] = value;
        next!();
    }
    DynShl {
        #[kind = Output]
        dest: StatePartIndex<StatePartKindBigSlots>,
        #[kind = Input]
        lhs: StatePartIndex<StatePartKindBigSlots>,
        #[kind = Input]
        rhs: StatePartIndex<StatePartKindBigSlots>,
    } => {
        let value = &state.big_slots[lhs] << state.big_slots[rhs].to_usize().expect("shl by invalid value");
        state.big_slots[dest] = value;
        next!();
    }
    DynShr {
        #[kind = Output]
        dest: StatePartIndex<StatePartKindBigSlots>,
        #[kind = Input]
        lhs: StatePartIndex<StatePartKindBigSlots>,
        #[kind = Input]
        rhs: StatePartIndex<StatePartKindBigSlots>,
    } => {
        assert!(!state.big_slots[rhs].is_negative(), "shr by invalid value");
        let value = state.big_slots[rhs].to_usize().map_or(BigInt::ZERO, |rhs| &state.big_slots[lhs] >> rhs);
        state.big_slots[dest] = value;
        next!();
    }
    Shl {
        #[kind = Output]
        dest: StatePartIndex<StatePartKindBigSlots>,
        #[kind = Input]
        lhs: StatePartIndex<StatePartKindBigSlots>,
        #[kind = Immediate]
        rhs: usize,
    } => {
        let value = &state.big_slots[lhs] << rhs;
        state.big_slots[dest] = value;
        next!();
    }
    Shr {
        #[kind = Output]
        dest: StatePartIndex<StatePartKindBigSlots>,
        #[kind = Input]
        lhs: StatePartIndex<StatePartKindBigSlots>,
        #[kind = Immediate]
        rhs: usize,
    } => {
        let value = &state.big_slots[lhs] >> rhs;
        state.big_slots[dest] = value;
        next!();
    }
    SliceInt {
        #[kind = Output]
        dest: StatePartIndex<StatePartKindBigSlots>,
        #[kind = Input]
        src: StatePartIndex<StatePartKindBigSlots>,
        #[kind = Immediate]
        start: usize,
        #[kind = Immediate]
        len: usize,
    } => {
        let value = &state.big_slots[src] >> start;
        state.big_slots[dest] = value & &*bigint_mask(len);
        next!();
    }
    CmpEq {
        #[kind = Output]
        dest: StatePartIndex<StatePartKindBigSlots>,
        #[kind = Input]
        lhs: StatePartIndex<StatePartKindBigSlots>,
        #[kind = Input]
        rhs: StatePartIndex<StatePartKindBigSlots>,
    } => {
        let lhs = &state.big_slots[lhs];
        let rhs = &state.big_slots[rhs];
        let value = BigInt::from(lhs == rhs);
        state.big_slots[dest] = value;
        next!();
    }
    CmpNe {
        #[kind = Output]
        dest: StatePartIndex<StatePartKindBigSlots>,
        #[kind = Input]
        lhs: StatePartIndex<StatePartKindBigSlots>,
        #[kind = Input]
        rhs: StatePartIndex<StatePartKindBigSlots>,
    } => {
        let lhs = &state.big_slots[lhs];
        let rhs = &state.big_slots[rhs];
        let value = BigInt::from(lhs != rhs);
        state.big_slots[dest] = value;
        next!();
    }
    CmpLt {
        #[kind = Output]
        dest: StatePartIndex<StatePartKindBigSlots>,
        #[kind = Input]
        lhs: StatePartIndex<StatePartKindBigSlots>,
        #[kind = Input]
        rhs: StatePartIndex<StatePartKindBigSlots>,
    } => {
        let lhs = &state.big_slots[lhs];
        let rhs = &state.big_slots[rhs];
        let value = BigInt::from(lhs < rhs);
        state.big_slots[dest] = value;
        next!();
    }
    CmpLe {
        #[kind = Output]
        dest: StatePartIndex<StatePartKindBigSlots>,
        #[kind = Input]
        lhs: StatePartIndex<StatePartKindBigSlots>,
        #[kind = Input]
        rhs: StatePartIndex<StatePartKindBigSlots>,
    } => {
        let lhs = &state.big_slots[lhs];
        let rhs = &state.big_slots[rhs];
        let value = BigInt::from(lhs <= rhs);
        state.big_slots[dest] = value;
        next!();
    }
    ReduceBitXor {
        #[kind = Output]
        dest: StatePartIndex<StatePartKindBigSlots>,
        #[kind = Input]
        src: StatePartIndex<StatePartKindBigSlots>,
        #[kind = Immediate]
        input_width: usize,
    } => {
        let src = &state.big_slots[src];
        let src = src & &*bigint_mask(input_width);
        let value = BigInt::from(
            src.to_biguint().expect("known to be non-negative").count_ones() % 2,
        );
        state.big_slots[dest] = value;
        next!();
    }
    Const {
        #[kind = Output]
        dest: StatePartIndex<StatePartKindBigSlots>,
        #[kind = Immediate]
        value: Interned<BigInt>,
    } => {
        state.big_slots[dest].clone_from(&value);
        next!();
    }
    Branch {
        #[kind = BranchTarget]
        target: usize,
    } => {
        branch!(target);
    }
    BranchIfZero {
        #[kind = BranchTarget]
        target: usize,
        #[kind = Input]
        value: StatePartIndex<StatePartKindBigSlots>,
    } => {
        if state.big_slots[value].is_zero() {
            branch!(target);
        } else {
            next!();
        }
    }
    BranchIfNonZero {
        #[kind = BranchTarget]
        target: usize,
        #[kind = Input]
        value: StatePartIndex<StatePartKindBigSlots>,
    } => {
        if state.big_slots[value].is_zero() {
            next!();
        } else {
            branch!(target);
        }
    }
    BranchIfSmallZero {
        #[kind = BranchTarget]
        target: usize,
        #[kind = Input]
        value: StatePartIndex<StatePartKindSmallSlots>,
    } => {
        if state.small_slots[value] == 0 {
            branch!(target);
        } else {
            next!();
        }
    }
    BranchIfSmallNonZero {
        #[kind = BranchTarget]
        target: usize,
        #[kind = Input]
        value: StatePartIndex<StatePartKindSmallSlots>,
    } => {
        if state.small_slots[value] == 0 {
            next!();
        } else {
            branch!(target);
        }
    }
    Return => {
        break;
    }
}